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

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Clan")]
[assembly: AssemblyDescription("Server-authoritative Valheim clan system")]
[assembly: AssemblyCompany("sighsorry")]
[assembly: AssemblyProduct("Clan")]
[assembly: AssemblyCopyright("Copyright © sighsorry 2026")]
[assembly: ComVisible(false)]
[assembly: Guid("4358610B-F3F4-4843-B7AF-98B7BC60DCDE")]
[assembly: AssemblyFileVersion("1.0.1")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.1.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Clan
{
	public enum ClanRole
	{
		Leader,
		Officer,
		Member,
		Guest
	}
	internal enum ClanRequestType
	{
		RequestSnapshot,
		CreateClan,
		Invite,
		Apply,
		AcceptInvite,
		DeclineInvite,
		AcceptApplication,
		RejectApplication,
		KickPlayer,
		TransferLeadership,
		SetRole,
		LeaveClan,
		SendClanChat,
		SendClanPing,
		UpdatePosition,
		CancelApplication,
		UpdateClanProfile,
		RequestDirectory,
		RenameClan,
		RequestHud
	}
	internal enum ClanOperationResultCode
	{
		None,
		Success,
		Unchanged,
		InvalidName,
		IdentityUnavailable,
		Unauthorized,
		ClanChanged,
		NameTaken,
		RateLimited,
		Unavailable,
		Failed,
		SnapshotRateLimited,
		IdentityRejected
	}
	internal enum ClanResponseType
	{
		Snapshot,
		Chat,
		MapPing,
		PositionUpdate,
		Directory,
		DirectoryInvalidated,
		Hud
	}
	internal enum ClanDirectoryPlayerState
	{
		None,
		Clan,
		Pending,
		Invited
	}
	internal enum ClanValidationField
	{
		None,
		ClanName,
		ClanDescription,
		ClanEmblemKey
	}
	internal enum ClanValidationError
	{
		Required,
		TooLong,
		RichText,
		ControlCharacters,
		InvalidUnicode,
		InvalidCharacters,
		TrailingSeparator,
		MissingLetterOrNumber,
		InvalidStartOrEnd
	}
	internal static class ClanDataRules
	{
		public const int MaxPlatformIdLength = 128;

		public const int MaxPlayerKeyLength = 160;

		public const int MaxPlayerNameLength = 64;

		public const int ClanIdLength = 32;

		public const int MaxClanNameLength = 40;

		public const int MaxClanDescriptionLength = 160;

		public const int MaxClanEmblemKeyLength = 32;

		public const int MaxChatMessageLength = 400;

		public const int MaxStatusLength = 1024;

		public const int MaxInviteIdLength = 64;

		public const int MaxClans = 1024;

		public const int MaxMembersPerClan = 512;

		public const int MaxApplicationsPerClan = 512;

		public const int MaxInvites = 4096;

		public const int MaxDirectoryPlayers = 1024;

		public const int MaxHudPlayers = 10;

		public const float MaxHudHealth = 1000000f;

		private static readonly object ValidationErrorDataKey = new object();

		public static string RequireText(string? value, int maxLength, string fieldName, bool allowEmpty = true, bool allowLineBreaks = false, ClanValidationField validationField = ClanValidationField.None)
		{
			string text = (value ?? "").Trim();
			if (!allowEmpty && text.Length == 0)
			{
				throw ValidationFailure(validationField, ClanValidationError.Required, fieldName + " is required.");
			}
			if (text.Length > maxLength)
			{
				throw ValidationFailure(validationField, ClanValidationError.TooLong, $"{fieldName} exceeds {maxLength} characters.");
			}
			if (text.IndexOf('<') >= 0 || text.IndexOf('>') >= 0)
			{
				throw ValidationFailure(validationField, ClanValidationError.RichText, fieldName + " cannot contain rich-text tags.");
			}
			string text2 = text;
			foreach (char c in text2)
			{
				if (char.IsControl(c) && (!allowLineBreaks || (c != '\r' && c != '\n' && c != '\t')))
				{
					throw ValidationFailure(validationField, ClanValidationError.ControlCharacters, fieldName + " contains unsupported control characters.");
				}
			}
			return text;
		}

		public static string RequireClanDescription(string? value, string fieldName = "clan description")
		{
			return RequireText(value, 160, fieldName, allowEmpty: true, allowLineBreaks: false, ClanValidationField.ClanDescription);
		}

		public static string ReadClanDescription(ZPackage package, string fieldName = "clan description")
		{
			return RequireClanDescription(package.ReadString(), fieldName);
		}

		public static void WriteClanDescription(ZPackage package, string? value, string fieldName = "clan description")
		{
			package.Write(RequireClanDescription(value, fieldName));
		}

		public static string RequireClanName(string? value, string fieldName = "clan name")
		{
			string text;
			try
			{
				text = (value ?? "").Normalize(NormalizationForm.FormC);
			}
			catch (ArgumentException innerException)
			{
				throw ValidationFailure(ClanValidationField.ClanName, ClanValidationError.InvalidUnicode, fieldName + " contains invalid Unicode data.", innerException);
			}
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			bool flag = false;
			string text2 = text;
			foreach (char c in text2)
			{
				if (CharUnicodeInfo.GetUnicodeCategory(c) == UnicodeCategory.SpaceSeparator)
				{
					if (stringBuilder.Length > 0 && !flag)
					{
						stringBuilder.Append(' ');
					}
					flag = true;
				}
				else
				{
					stringBuilder.Append(c);
					flag = false;
				}
			}
			string text3 = stringBuilder.ToString().Trim(new char[1] { ' ' });
			if (text3.Length == 0)
			{
				throw ValidationFailure(ClanValidationField.ClanName, ClanValidationError.Required, fieldName + " is required.");
			}
			int num = 0;
			bool flag2 = false;
			bool flag3 = true;
			bool flag4 = false;
			int num2;
			for (int j = 0; j < text3.Length; j += num2)
			{
				char c2 = text3[j];
				num2 = 1;
				if (char.IsHighSurrogate(c2))
				{
					if (j + 1 >= text3.Length || !char.IsLowSurrogate(text3[j + 1]))
					{
						throw ValidationFailure(ClanValidationField.ClanName, ClanValidationError.InvalidUnicode, fieldName + " contains invalid Unicode data.");
					}
					num2 = 2;
				}
				else if (char.IsLowSurrogate(c2))
				{
					throw ValidationFailure(ClanValidationField.ClanName, ClanValidationError.InvalidUnicode, fieldName + " contains invalid Unicode data.");
				}
				UnicodeCategory unicodeCategory = CharUnicodeInfo.GetUnicodeCategory(text3, j);
				bool flag5 = (uint)unicodeCategory <= 4u;
				bool flag6 = flag5;
				flag5 = (uint)(unicodeCategory - 8) <= 2u;
				bool flag7 = flag5;
				flag5 = (uint)(unicodeCategory - 5) <= 2u;
				bool flag8 = flag5;
				bool flag9 = num2 == 1 && (c2 == ' ' || c2 == '-' || c2 == '_' || c2 == '·');
				if (flag6 || flag7)
				{
					flag2 = true;
					flag3 = false;
					flag4 = true;
				}
				else if (flag8 && flag4)
				{
					flag3 = false;
				}
				else
				{
					if (!flag9 || flag3)
					{
						throw ValidationFailure(ClanValidationField.ClanName, ClanValidationError.InvalidCharacters, fieldName + " can contain only letters, numbers, marks, spaces, '-', '_', or '·'.");
					}
					flag3 = true;
					flag4 = false;
				}
				num++;
				if (num > 40)
				{
					throw ValidationFailure(ClanValidationField.ClanName, ClanValidationError.TooLong, $"{fieldName} exceeds {40} Unicode characters.");
				}
			}
			if (flag3)
			{
				throw ValidationFailure(ClanValidationField.ClanName, ClanValidationError.TrailingSeparator, fieldName + " cannot end with a separator.");
			}
			if (!flag2)
			{
				throw ValidationFailure(ClanValidationField.ClanName, ClanValidationError.MissingLetterOrNumber, fieldName + " must contain a letter or number.");
			}
			return text3;
		}

		public static string RequireOptionalClanName(string? value, string fieldName = "clan name")
		{
			if (!string.IsNullOrWhiteSpace(value))
			{
				return RequireClanName(value, fieldName);
			}
			return "";
		}

		public static string ReadClanName(ZPackage package, string fieldName = "clan name")
		{
			return RequireClanName(package.ReadString(), fieldName);
		}

		public static string ReadOptionalClanName(ZPackage package, string fieldName = "clan name")
		{
			return RequireOptionalClanName(package.ReadString(), fieldName);
		}

		public static void WriteClanName(ZPackage package, string? value, string fieldName = "clan name")
		{
			package.Write(RequireClanName(value, fieldName));
		}

		public static void WriteOptionalClanName(ZPackage package, string? value, string fieldName = "clan name")
		{
			package.Write(RequireOptionalClanName(value, fieldName));
		}

		public static string ReadText(ZPackage package, int maxLength, string fieldName, bool allowEmpty = true, bool allowLineBreaks = false)
		{
			return RequireText(package.ReadString(), maxLength, fieldName, allowEmpty, allowLineBreaks);
		}

		public static void WriteText(ZPackage package, string? value, int maxLength, string fieldName, bool allowEmpty = true, bool allowLineBreaks = false)
		{
			package.Write(RequireText(value, maxLength, fieldName, allowEmpty, allowLineBreaks));
		}

		public static string RequirePlayerKey(string? value, string fieldName = "player key")
		{
			string text = RequireText(value, 160, fieldName, allowEmpty: false);
			if (!TryParsePlayerKey(text, out string _, out long _))
			{
				throw new InvalidDataException(fieldName + " is invalid.");
			}
			return text;
		}

		public static string ReadPlayerKey(ZPackage package, string fieldName = "player key")
		{
			return RequirePlayerKey(package.ReadString(), fieldName);
		}

		public static void WritePlayerKey(ZPackage package, string? value, string fieldName = "player key")
		{
			package.Write(RequirePlayerKey(value, fieldName));
		}

		public static string RequirePlatformId(string? value, string fieldName = "platform id")
		{
			return RequireText(value, 128, fieldName, allowEmpty: false);
		}

		public static long RequireCharacterPlayerId(long value, string fieldName = "character player id")
		{
			if (value == 0L)
			{
				throw new InvalidDataException(fieldName + " must be non-zero.");
			}
			return value;
		}

		public static string BuildPlayerKey(string? platformId, long playerId)
		{
			string text = RequirePlatformId(platformId);
			long num = RequireCharacterPlayerId(playerId);
			return text.Length.ToString(CultureInfo.InvariantCulture) + ":" + text + ":" + num.ToString(CultureInfo.InvariantCulture);
		}

		public static bool TryParsePlayerKey(string? value, out string platformId, out long playerId)
		{
			platformId = "";
			playerId = 0L;
			string text = value ?? "";
			int num = text.IndexOf(':');
			if (num <= 0 || !int.TryParse(text.Substring(0, num), NumberStyles.None, CultureInfo.InvariantCulture, out var result) || result <= 0 || result > 128)
			{
				return false;
			}
			int num2 = num + 1;
			int num3 = num2 + result;
			if (num3 >= text.Length || text[num3] != ':')
			{
				return false;
			}
			string text2 = text.Substring(num2, result);
			if (!long.TryParse(text.Substring(num3 + 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) || result2 == 0L || NormalizePlatformId(text2).Length == 0)
			{
				return false;
			}
			string x;
			try
			{
				x = BuildPlayerKey(text2, result2);
			}
			catch (InvalidDataException)
			{
				return false;
			}
			if (!StringComparer.Ordinal.Equals(x, text))
			{
				return false;
			}
			platformId = text2;
			playerId = result2;
			return true;
		}

		public static string ReadPlayerName(ZPackage package, string fieldName = "player name")
		{
			return ReadText(package, 64, fieldName);
		}

		public static void WritePlayerName(ZPackage package, string? value, string fieldName = "player name")
		{
			WriteText(package, value, 64, fieldName);
		}

		public static string RequireClanId(string? value, string fieldName = "clan id")
		{
			string text = RequireText(value, 32, fieldName, allowEmpty: false);
			if (text.Length != 32 || !Guid.TryParseExact(text, "N", out var result) || result == Guid.Empty || !StringComparer.Ordinal.Equals(result.ToString("N"), text))
			{
				throw new InvalidDataException(fieldName + " is invalid.");
			}
			return text;
		}

		public static string RequireOptionalClanId(string? value, string fieldName = "clan id")
		{
			if (!string.IsNullOrWhiteSpace(value))
			{
				return RequireClanId(value, fieldName);
			}
			return "";
		}

		public static string ReadClanId(ZPackage package, string fieldName = "clan id")
		{
			return RequireClanId(package.ReadString(), fieldName);
		}

		public static string ReadOptionalClanId(ZPackage package, string fieldName = "clan id")
		{
			return RequireOptionalClanId(package.ReadString(), fieldName);
		}

		public static void WriteClanId(ZPackage package, string? value, string fieldName = "clan id")
		{
			package.Write(RequireClanId(value, fieldName));
		}

		public static void WriteOptionalClanId(ZPackage package, string? value, string fieldName = "clan id")
		{
			package.Write(RequireOptionalClanId(value, fieldName));
		}

		public static string RequireClanEmblemKey(string? value, string fieldName = "clan emblem key")
		{
			string text = RequireText(value, 32, fieldName, allowEmpty: true, allowLineBreaks: false, ClanValidationField.ClanEmblemKey);
			if (text.Length == 0)
			{
				return text;
			}
			if (!IsLowerAsciiLetterOrDigit(text[0]) || !IsLowerAsciiLetterOrDigit(text[text.Length - 1]))
			{
				throw ValidationFailure(ClanValidationField.ClanEmblemKey, ClanValidationError.InvalidStartOrEnd, fieldName + " must start and end with a lowercase ASCII letter or digit.");
			}
			string text2 = text;
			foreach (char c in text2)
			{
				if (!IsLowerAsciiLetterOrDigit(c) && c != '_' && c != '-')
				{
					throw ValidationFailure(ClanValidationField.ClanEmblemKey, ClanValidationError.InvalidCharacters, fieldName + " can contain only lowercase ASCII letters, digits, '_' or '-'.");
				}
			}
			return text;
		}

		public static string ReadClanEmblemKey(ZPackage package, string fieldName = "clan emblem key")
		{
			return RequireClanEmblemKey(package.ReadString(), fieldName);
		}

		public static void WriteClanEmblemKey(ZPackage package, string? value, string fieldName = "clan emblem key")
		{
			package.Write(RequireClanEmblemKey(value, fieldName));
		}

		public static T RequireEnum<T>(T value, string fieldName) where T : struct, Enum
		{
			if (!Enum.IsDefined(typeof(T), value))
			{
				throw new InvalidDataException($"{fieldName} has an unknown value ({Convert.ToInt32(value)}).");
			}
			return value;
		}

		public static T ReadEnum<T>(ZPackage package, string fieldName) where T : struct, Enum
		{
			int num = package.ReadInt();
			if (!Enum.IsDefined(typeof(T), num))
			{
				throw new InvalidDataException($"{fieldName} has an unknown value ({num}).");
			}
			return (T)Enum.ToObject(typeof(T), num);
		}

		public static ClanRole RequireAssignableRole(ClanRole role, string fieldName)
		{
			RequireEnum(role, fieldName);
			if (role != ClanRole.Officer && role != ClanRole.Member && role != ClanRole.Guest)
			{
				throw new InvalidDataException(fieldName + " must be Officer, Member, or Guest.");
			}
			return role;
		}

		public static ClanRole ReadAssignableRole(ZPackage package, string fieldName)
		{
			return RequireAssignableRole(ReadEnum<ClanRole>(package, fieldName), fieldName);
		}

		public static int GetRolePower(ClanRole role)
		{
			return RequireEnum(role, "clan role") switch
			{
				ClanRole.Leader => 3, 
				ClanRole.Officer => 2, 
				ClanRole.Member => 1, 
				ClanRole.Guest => 0, 
				_ => throw new InvalidDataException("Clan role is unsupported."), 
			};
		}

		public static int RequireRange(int value, int minimum, int maximum, string fieldName)
		{
			if (value < minimum || value > maximum)
			{
				throw new InvalidDataException(fieldName + " is outside the supported range.");
			}
			return value;
		}

		public static long RequireRequestId(long value, string fieldName = "request id")
		{
			if (value <= 0)
			{
				throw new InvalidDataException(fieldName + " must be positive.");
			}
			return value;
		}

		public static long RequireOptionalRequestId(long value, string fieldName = "response request id")
		{
			if (value < 0)
			{
				throw new InvalidDataException(fieldName + " cannot be negative.");
			}
			return value;
		}

		public static int ReadCount(ZPackage package, int maximum, string fieldName)
		{
			return RequireRange(package.ReadInt(), 0, maximum, fieldName + " count");
		}

		public static void RequireCount(int count, int maximum, string fieldName)
		{
			RequireRange(count, 0, maximum, fieldName + " count");
		}

		public static Vector3 ReadFiniteVector(ZPackage package, string fieldName)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = package.ReadVector3();
			RequireFiniteVector(val, fieldName);
			return val;
		}

		public static void RequireFiniteVector(Vector3 value, string fieldName)
		{
			//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) || !IsFinite(value.z))
			{
				throw new InvalidDataException(fieldName + " must contain finite coordinates.");
			}
		}

		public static string NormalizePlayerKey(string? value)
		{
			try
			{
				return RequirePlayerKey(value);
			}
			catch (InvalidDataException)
			{
				return "";
			}
		}

		public static string NormalizePlatformId(string? value)
		{
			try
			{
				return RequirePlatformId(value);
			}
			catch (InvalidDataException)
			{
				return "";
			}
		}

		public static string SanitizePlayerName(string? value)
		{
			string text = (value ?? "").Replace("<", " ").Replace(">", " ");
			StringBuilder stringBuilder = new StringBuilder(Math.Min(text.Length, 64));
			for (int i = 0; i < text.Length; i++)
			{
				if (stringBuilder.Length >= 64)
				{
					break;
				}
				char c = text[i];
				if (char.IsControl(c))
				{
					continue;
				}
				bool flag = char.IsHighSurrogate(c) && i + 1 < text.Length && char.IsLowSurrogate(text[i + 1]);
				if (!char.IsSurrogate(c) || flag)
				{
					int num = ((!flag) ? 1 : 2);
					if (stringBuilder.Length > 64 - num)
					{
						break;
					}
					stringBuilder.Append(c);
					if (flag)
					{
						stringBuilder.Append(text[++i]);
					}
				}
			}
			return stringBuilder.ToString().Trim();
		}

		public static bool TryGetValidationError(InvalidDataException exception, out ClanValidationField field, out ClanValidationError error)
		{
			if (exception.Data[ValidationErrorDataKey] is (ClanValidationField, ClanValidationError) tuple)
			{
				(field, error) = tuple;
				return true;
			}
			field = ClanValidationField.None;
			error = ClanValidationError.Required;
			return false;
		}

		private static InvalidDataException ValidationFailure(ClanValidationField field, ClanValidationError error, string message, Exception? innerException = null)
		{
			InvalidDataException ex = new InvalidDataException(message, innerException);
			if (field != ClanValidationField.None)
			{
				ex.Data[ValidationErrorDataKey] = (field, error);
			}
			return ex;
		}

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

		private static bool IsLowerAsciiLetterOrDigit(char value)
		{
			switch (value)
			{
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			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':
				return true;
			default:
				return false;
			}
		}
	}
	internal readonly struct ClanPlayerRef : IEquatable<ClanPlayerRef>
	{
		public readonly string Id;

		public readonly string PlatformId;

		public readonly long CharacterPlayerId;

		public readonly string Name;

		public bool IsValid
		{
			get
			{
				if (!string.IsNullOrWhiteSpace(PlatformId) && CharacterPlayerId != 0L)
				{
					return !string.IsNullOrWhiteSpace(Id);
				}
				return false;
			}
		}

		public ClanPlayerRef(string? platformId, long playerId, string? name)
		{
			PlatformId = ClanDataRules.NormalizePlatformId(platformId);
			CharacterPlayerId = playerId;
			Name = ClanDataRules.SanitizePlayerName(name);
			Id = ((PlatformId.Length == 0 || CharacterPlayerId == 0L) ? "" : ClanDataRules.BuildPlayerKey(PlatformId, CharacterPlayerId));
		}

		public static ClanPlayerRef Local()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			IDistributionPlatform distributionPlatform = PlatformManager.DistributionPlatform;
			string platformId = ((((distributionPlatform != null) ? distributionPlatform.LocalUser : null) != null) ? ((object)((IUser)distributionPlatform.LocalUser).PlatformUserID/*cast due to .constrained prefix*/).ToString() : "");
			Player localPlayer = Player.m_localPlayer;
			long num2;
			if (localPlayer == null)
			{
				Game instance = Game.instance;
				long? obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					PlayerProfile playerProfile = instance.GetPlayerProfile();
					obj = ((playerProfile != null) ? new long?(playerProfile.GetPlayerID()) : ((long?)null));
				}
				long? num = obj;
				num2 = num.GetValueOrDefault();
			}
			else
			{
				num2 = localPlayer.GetPlayerID();
			}
			long playerId = num2;
			Game instance2 = Game.instance;
			object obj2;
			if (instance2 == null)
			{
				obj2 = null;
			}
			else
			{
				PlayerProfile playerProfile2 = instance2.GetPlayerProfile();
				obj2 = ((playerProfile2 != null) ? playerProfile2.GetName() : null);
			}
			if (obj2 == null)
			{
				obj2 = "Unknown";
			}
			string name = (string)obj2;
			return new ClanPlayerRef(platformId, playerId, name);
		}

		public void Write(ZPackage package)
		{
			ClanDataRules.WriteText(package, PlatformId, 128, "platform id", allowEmpty: false);
			package.Write(ClanDataRules.RequireCharacterPlayerId(CharacterPlayerId));
			ClanDataRules.WritePlayerName(package, Name);
		}

		public static ClanPlayerRef Read(ZPackage package)
		{
			return new ClanPlayerRef(ClanDataRules.ReadText(package, 128, "platform id", allowEmpty: false), ClanDataRules.RequireCharacterPlayerId(package.ReadLong()), ClanDataRules.ReadPlayerName(package));
		}

		public bool Equals(ClanPlayerRef other)
		{
			return StringComparer.Ordinal.Equals(Id, other.Id);
		}

		public override bool Equals(object? obj)
		{
			if (obj is ClanPlayerRef other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			if (Id != null)
			{
				return StringComparer.Ordinal.GetHashCode(Id);
			}
			return 0;
		}

		public override string ToString()
		{
			string text = (IsValid ? $"{PlatformId}/{CharacterPlayerId}" : "");
			if (!string.IsNullOrWhiteSpace(Name))
			{
				return Name + " (" + text + ")";
			}
			return text;
		}

		public static bool operator ==(ClanPlayerRef left, ClanPlayerRef right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(ClanPlayerRef left, ClanPlayerRef right)
		{
			return !left.Equals(right);
		}
	}
	internal sealed class ClanMember
	{
		public ClanPlayerRef Player;

		public ClanRole Role = ClanRole.Member;

		public float LastClanChatTime = float.NegativeInfinity;

		public float LastClanPingTime = float.NegativeInfinity;
	}
	internal sealed class ClanInvite
	{
		public string InviteId = Guid.NewGuid().ToString("N");

		public string ClanId = "";

		public string FromName = "";

		public ClanPlayerRef Target;
	}
	internal sealed class ClanState
	{
		public long CreationOrder;

		public string Name = "";

		public string Description = "";

		public string EmblemKey = "";

		public readonly Dictionary<string, ClanMember> Members = new Dictionary<string, ClanMember>(StringComparer.Ordinal);

		public readonly Dictionary<string, ClanPlayerRef> Applications = new Dictionary<string, ClanPlayerRef>(StringComparer.Ordinal);

		public string ClanId { get; }

		public ClanState(string clanId)
		{
			ClanId = ClanDataRules.RequireClanId(clanId);
		}

		public bool IsLeader(ClanPlayerRef player)
		{
			if (player.IsValid && Members.TryGetValue(player.Id, out ClanMember value))
			{
				return value.Role == ClanRole.Leader;
			}
			return false;
		}
	}
	internal sealed class ClanRequest
	{
		public ClanRequestType Type;

		public string ClanId = "";

		public string ClanName = "";

		public string TargetId = "";

		public string InviteId = "";

		public string Message = "";

		public string Description = "";

		public string EmblemKey = "";

		public ClanRole Role = ClanRole.Member;

		public long RequestId;

		public long HudSelectionRevision;

		public long HudStateRevision;

		public Vector3 Position = Vector3.zero;

		public static ClanRequest Simple(ClanRequestType type)
		{
			return new ClanRequest
			{
				Type = type
			};
		}

		public void Write(ZPackage package)
		{
			//IL_0285: 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)
			ClanDataRules.RequireEnum(Type, "clan request type");
			package.Write((int)Type);
			switch (Type)
			{
			case ClanRequestType.RequestSnapshot:
			case ClanRequestType.CancelApplication:
				break;
			case ClanRequestType.LeaveClan:
				ClanDataRules.WriteClanId(package, ClanId);
				break;
			case ClanRequestType.RequestHud:
				ClanDataRules.WriteClanId(package, ClanId);
				package.Write(ClanDataRules.RequireOptionalRequestId(HudSelectionRevision, "HUD selection revision"));
				package.Write(ClanDataRules.RequireOptionalRequestId(HudStateRevision, "HUD state revision"));
				break;
			case ClanRequestType.RequestDirectory:
				package.Write(ClanDataRules.RequireRequestId(RequestId));
				break;
			case ClanRequestType.CreateClan:
				package.Write(ClanDataRules.RequireRequestId(RequestId));
				ClanDataRules.WriteClanName(package, ClanName);
				ClanDataRules.WriteClanDescription(package, Description);
				ClanDataRules.WriteClanEmblemKey(package, EmblemKey);
				break;
			case ClanRequestType.Invite:
			case ClanRequestType.AcceptApplication:
			case ClanRequestType.RejectApplication:
			case ClanRequestType.KickPlayer:
			case ClanRequestType.TransferLeadership:
				ClanDataRules.WriteClanId(package, ClanId);
				ClanDataRules.WritePlayerKey(package, TargetId, "target player key");
				break;
			case ClanRequestType.Apply:
				ClanDataRules.WriteClanId(package, ClanId);
				break;
			case ClanRequestType.AcceptInvite:
			case ClanRequestType.DeclineInvite:
				ClanDataRules.WriteText(package, InviteId, 64, "invite id", allowEmpty: false);
				break;
			case ClanRequestType.SetRole:
				ClanDataRules.WriteClanId(package, ClanId);
				ClanDataRules.WritePlayerKey(package, TargetId, "target player key");
				package.Write((int)ClanDataRules.RequireAssignableRole(Role, "clan role"));
				break;
			case ClanRequestType.UpdateClanProfile:
				package.Write(ClanDataRules.RequireRequestId(RequestId));
				ClanDataRules.WriteClanId(package, ClanId);
				ClanDataRules.WriteClanName(package, ClanName);
				ClanDataRules.WriteClanDescription(package, Description);
				ClanDataRules.WriteClanEmblemKey(package, EmblemKey);
				break;
			case ClanRequestType.RenameClan:
				package.Write(ClanDataRules.RequireRequestId(RequestId));
				ClanDataRules.WriteClanId(package, ClanId);
				ClanDataRules.WriteClanName(package, ClanName);
				break;
			case ClanRequestType.SendClanChat:
				ClanDataRules.WriteClanId(package, ClanId);
				ClanDataRules.WriteText(package, Message, 400, "clan chat message", allowEmpty: false);
				break;
			case ClanRequestType.SendClanPing:
			case ClanRequestType.UpdatePosition:
				ClanDataRules.WriteClanId(package, ClanId);
				ClanDataRules.RequireFiniteVector(Position, "position");
				package.Write(Position);
				break;
			default:
				throw new InvalidDataException($"Unknown clan request type ({(int)Type}).");
			}
		}

		public static ClanRequest Read(ZPackage package)
		{
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			ClanRequest clanRequest = new ClanRequest
			{
				Type = ClanDataRules.ReadEnum<ClanRequestType>(package, "clan request type")
			};
			switch (clanRequest.Type)
			{
			case ClanRequestType.LeaveClan:
				clanRequest.ClanId = ClanDataRules.ReadClanId(package);
				break;
			case ClanRequestType.RequestHud:
				clanRequest.ClanId = ClanDataRules.ReadClanId(package);
				clanRequest.HudSelectionRevision = ClanDataRules.RequireOptionalRequestId(package.ReadLong(), "HUD selection revision");
				clanRequest.HudStateRevision = ClanDataRules.RequireOptionalRequestId(package.ReadLong(), "HUD state revision");
				break;
			case ClanRequestType.RequestDirectory:
				clanRequest.RequestId = ClanDataRules.RequireRequestId(package.ReadLong());
				break;
			case ClanRequestType.CreateClan:
				clanRequest.RequestId = ClanDataRules.RequireRequestId(package.ReadLong());
				clanRequest.ClanName = ClanDataRules.ReadClanName(package);
				clanRequest.Description = ClanDataRules.ReadClanDescription(package);
				clanRequest.EmblemKey = ClanDataRules.ReadClanEmblemKey(package);
				break;
			case ClanRequestType.Invite:
			case ClanRequestType.AcceptApplication:
			case ClanRequestType.RejectApplication:
			case ClanRequestType.KickPlayer:
			case ClanRequestType.TransferLeadership:
				clanRequest.ClanId = ClanDataRules.ReadClanId(package);
				clanRequest.TargetId = ClanDataRules.ReadPlayerKey(package, "target player key");
				break;
			case ClanRequestType.Apply:
				clanRequest.ClanId = ClanDataRules.ReadClanId(package);
				break;
			case ClanRequestType.AcceptInvite:
			case ClanRequestType.DeclineInvite:
				clanRequest.InviteId = ClanDataRules.ReadText(package, 64, "invite id", allowEmpty: false);
				break;
			case ClanRequestType.SetRole:
				clanRequest.ClanId = ClanDataRules.ReadClanId(package);
				clanRequest.TargetId = ClanDataRules.ReadPlayerKey(package, "target player key");
				clanRequest.Role = ClanDataRules.ReadAssignableRole(package, "clan role");
				break;
			case ClanRequestType.UpdateClanProfile:
				clanRequest.RequestId = ClanDataRules.RequireRequestId(package.ReadLong());
				clanRequest.ClanId = ClanDataRules.ReadClanId(package);
				clanRequest.ClanName = ClanDataRules.ReadClanName(package);
				clanRequest.Description = ClanDataRules.ReadClanDescription(package);
				clanRequest.EmblemKey = ClanDataRules.ReadClanEmblemKey(package);
				break;
			case ClanRequestType.RenameClan:
				clanRequest.RequestId = ClanDataRules.RequireRequestId(package.ReadLong());
				clanRequest.ClanId = ClanDataRules.ReadClanId(package);
				clanRequest.ClanName = ClanDataRules.ReadClanName(package);
				break;
			case ClanRequestType.SendClanChat:
				clanRequest.ClanId = ClanDataRules.ReadClanId(package);
				clanRequest.Message = ClanDataRules.ReadText(package, 400, "clan chat message", allowEmpty: false);
				break;
			case ClanRequestType.SendClanPing:
			case ClanRequestType.UpdatePosition:
				clanRequest.ClanId = ClanDataRules.ReadClanId(package);
				clanRequest.Position = ClanDataRules.ReadFiniteVector(package, "position");
				break;
			}
			if (package.GetPos() != package.Size())
			{
				throw new InvalidDataException("Clan request contains unexpected trailing data.");
			}
			return clanRequest;
		}
	}
	internal sealed class ClanPlayerSummary
	{
		public ClanPlayerRef Player;

		public ClanRole Role = ClanRole.Member;

		public bool IsSelf;

		public bool IsOnline;

		public string Id => Player.Id;

		public string Name => Player.Name;

		public void Write(ZPackage package)
		{
			if (!Player.IsValid)
			{
				throw new InvalidDataException("roster player identity is invalid.");
			}
			Player.Write(package);
			package.Write((int)ClanDataRules.RequireEnum(Role, "clan role"));
			package.Write(IsSelf);
			package.Write(IsOnline);
		}

		public static ClanPlayerSummary Read(ZPackage package)
		{
			return new ClanPlayerSummary
			{
				Player = ClanPlayerRef.Read(package),
				Role = ClanDataRules.ReadEnum<ClanRole>(package, "clan role"),
				IsSelf = package.ReadBool(),
				IsOnline = package.ReadBool()
			};
		}
	}
	internal sealed class ClanHudPlayerSummary
	{
		public string PlayerId = "";

		public bool HasHealth;

		public float CurrentHealth;

		public float MaxHealth;

		public void Write(ZPackage package)
		{
			ClanDataRules.WritePlayerKey(package, PlayerId, "HUD player key");
			package.Write(HasHealth);
			if (HasHealth)
			{
				ValidateHealth(CurrentHealth, MaxHealth);
				package.Write(CurrentHealth);
				package.Write(MaxHealth);
			}
		}

		public static ClanHudPlayerSummary Read(ZPackage package)
		{
			ClanHudPlayerSummary clanHudPlayerSummary = new ClanHudPlayerSummary
			{
				PlayerId = ClanDataRules.ReadPlayerKey(package, "HUD player key"),
				HasHealth = package.ReadBool()
			};
			if (clanHudPlayerSummary.HasHealth)
			{
				clanHudPlayerSummary.CurrentHealth = package.ReadSingle();
				clanHudPlayerSummary.MaxHealth = package.ReadSingle();
				ValidateHealth(clanHudPlayerSummary.CurrentHealth, clanHudPlayerSummary.MaxHealth);
			}
			return clanHudPlayerSummary;
		}

		private static void ValidateHealth(float currentHealth, float maxHealth)
		{
			if (float.IsNaN(currentHealth) || float.IsInfinity(currentHealth) || float.IsNaN(maxHealth) || float.IsInfinity(maxHealth) || maxHealth <= 0f || maxHealth > 1000000f || currentHealth < 0f || currentHealth > maxHealth)
			{
				throw new InvalidDataException("HUD health is outside the supported range.");
			}
		}
	}
	internal sealed class ClanHudSnapshot
	{
		public string ClanId = "";

		public long SelectionRevision;

		public long StateRevision;

		public bool ReplaceSelection;

		public readonly List<ClanHudPlayerSummary> Players = new List<ClanHudPlayerSummary>();

		public void Write(ZPackage package)
		{
			ClanDataRules.WriteOptionalClanId(package, ClanId, "HUD clan id");
			package.Write(ClanDataRules.RequireOptionalRequestId(SelectionRevision, "HUD selection revision"));
			package.Write(ClanDataRules.RequireOptionalRequestId(StateRevision, "HUD state revision"));
			package.Write(ReplaceSelection);
			ClanDataRules.RequireCount(Players.Count, 10, "HUD player");
			package.Write(Players.Count);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (ClanHudPlayerSummary player in Players)
			{
				if (!hashSet.Add(player.PlayerId))
				{
					throw new InvalidDataException("HUD snapshot contains a duplicate player.");
				}
				player.Write(package);
			}
		}

		public static ClanHudSnapshot Read(ZPackage package)
		{
			ClanHudSnapshot clanHudSnapshot = new ClanHudSnapshot
			{
				ClanId = ClanDataRules.ReadOptionalClanId(package, "HUD clan id"),
				SelectionRevision = ClanDataRules.RequireOptionalRequestId(package.ReadLong(), "HUD selection revision"),
				StateRevision = ClanDataRules.RequireOptionalRequestId(package.ReadLong(), "HUD state revision"),
				ReplaceSelection = package.ReadBool()
			};
			int num = ClanDataRules.ReadCount(package, 10, "HUD player");
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int i = 0; i < num; i++)
			{
				ClanHudPlayerSummary clanHudPlayerSummary = ClanHudPlayerSummary.Read(package);
				if (!hashSet.Add(clanHudPlayerSummary.PlayerId))
				{
					throw new InvalidDataException("HUD snapshot contains a duplicate player.");
				}
				clanHudSnapshot.Players.Add(clanHudPlayerSummary);
			}
			return clanHudSnapshot;
		}
	}
	internal sealed class ClanPublicSummary
	{
		public string ClanId = "";

		public string Name = "";

		public string Description = "";

		public string EmblemKey = "";

		public string LeaderName = "";

		public int MemberCount;

		public void Write(ZPackage package)
		{
			ClanDataRules.WriteClanId(package, ClanId);
			ClanDataRules.WriteClanName(package, Name);
			ClanDataRules.WriteClanDescription(package, Description);
			ClanDataRules.WriteClanEmblemKey(package, EmblemKey);
			ClanDataRules.WritePlayerName(package, LeaderName, "clan leader name");
			package.Write(ClanDataRules.RequireRange(MemberCount, 0, 512, "clan member count"));
		}

		public static ClanPublicSummary Read(ZPackage package)
		{
			return new ClanPublicSummary
			{
				ClanId = ClanDataRules.ReadClanId(package),
				Name = ClanDataRules.ReadClanName(package),
				Description = ClanDataRules.ReadClanDescription(package),
				EmblemKey = ClanDataRules.ReadClanEmblemKey(package),
				LeaderName = ClanDataRules.ReadPlayerName(package, "clan leader name"),
				MemberCount = ClanDataRules.RequireRange(package.ReadInt(), 0, 512, "clan member count")
			};
		}
	}
	internal sealed class ClanApplicationSummary
	{
		public string PlayerId = "";

		public string PlayerName = "";

		public void Write(ZPackage package)
		{
			ClanDataRules.WritePlayerKey(package, PlayerId, "applicant key");
			ClanDataRules.WritePlayerName(package, PlayerName, "applicant name");
		}

		public static ClanApplicationSummary Read(ZPackage package)
		{
			return new ClanApplicationSummary
			{
				PlayerId = ClanDataRules.ReadPlayerKey(package, "applicant key"),
				PlayerName = ClanDataRules.ReadPlayerName(package, "applicant name")
			};
		}
	}
	internal sealed class ClanInviteSummary
	{
		public string InviteId = "";

		public string ClanId = "";

		public string ClanName = "";

		public string FromName = "";

		public void Write(ZPackage package)
		{
			ClanDataRules.WriteText(package, InviteId, 64, "invite id", allowEmpty: false);
			ClanDataRules.WriteClanId(package, ClanId);
			ClanDataRules.WriteClanName(package, ClanName);
			ClanDataRules.WritePlayerName(package, FromName, "inviter name");
		}

		public static ClanInviteSummary Read(ZPackage package)
		{
			return new ClanInviteSummary
			{
				InviteId = ClanDataRules.ReadText(package, 64, "invite id", allowEmpty: false),
				ClanId = ClanDataRules.ReadClanId(package),
				ClanName = ClanDataRules.ReadClanName(package),
				FromName = ClanDataRules.ReadPlayerName(package, "inviter name")
			};
		}
	}
	internal sealed class ClanClientSnapshot
	{
		public string Status = "";

		public long ResponseRequestId;

		public ClanOperationResultCode ResponseResultCode;

		public string ClanId = "";

		public string ClanName = "";

		public string ClanDescription = "";

		public string ClanEmblemKey = "";

		public ClanRole SelfRole = ClanRole.Member;

		public string PrimaryClanId = "";

		public string PrimaryClanName = "";

		public ClanRole PrimaryRole = ClanRole.Member;

		public string GuestClanId = "";

		public string GuestClanName = "";

		public readonly List<ClanPlayerSummary> Roster = new List<ClanPlayerSummary>();

		public readonly List<ClanApplicationSummary> Applications = new List<ClanApplicationSummary>();

		public ClanInviteSummary? Invite;

		public string OwnApplicationClanId = "";

		public string OwnApplicationClanName = "";

		public bool HasClan => !string.IsNullOrWhiteSpace(ClanId);

		public bool IsLeader
		{
			get
			{
				if (HasClan)
				{
					return SelfRole == ClanRole.Leader;
				}
				return false;
			}
		}

		public bool CanModerate
		{
			get
			{
				bool flag = HasClan;
				if (flag)
				{
					ClanRole selfRole = SelfRole;
					bool flag2 = (uint)selfRole <= 1u;
					flag = flag2;
				}
				return flag;
			}
		}

		public bool HasPrimaryClan => !string.IsNullOrWhiteSpace(PrimaryClanId);

		public bool HasGuestClan => !string.IsNullOrWhiteSpace(GuestClanId);

		public bool HasAnyClan
		{
			get
			{
				if (!HasPrimaryClan)
				{
					return HasGuestClan;
				}
				return true;
			}
		}

		public bool HasOwnApplication => !string.IsNullOrWhiteSpace(OwnApplicationClanId);

		public bool IsConnectedToClan(string clanId)
		{
			if (!string.IsNullOrWhiteSpace(clanId))
			{
				if (!StringComparer.Ordinal.Equals(PrimaryClanId, clanId))
				{
					return StringComparer.Ordinal.Equals(GuestClanId, clanId);
				}
				return true;
			}
			return false;
		}

		public ClanRole? GetRoleForClan(string clanId)
		{
			if (!string.IsNullOrWhiteSpace(clanId) && StringComparer.Ordinal.Equals(PrimaryClanId, clanId))
			{
				return PrimaryRole;
			}
			if (!string.IsNullOrWhiteSpace(clanId) && StringComparer.Ordinal.Equals(GuestClanId, clanId))
			{
				return ClanRole.Guest;
			}
			return null;
		}

		public void Write(ZPackage package)
		{
			ClanDataRules.RequireCount(Roster.Count, 512, "roster");
			ClanDataRules.RequireCount(Applications.Count, 512, "application");
			ClanDataRules.WriteText(package, Status, 1024, "snapshot status", allowEmpty: true, allowLineBreaks: true);
			package.Write(ClanDataRules.RequireOptionalRequestId(ResponseRequestId));
			package.Write((int)ClanDataRules.RequireEnum(ResponseResultCode, "operation result"));
			ClanDataRules.WriteOptionalClanId(package, ClanId);
			ClanDataRules.WriteOptionalClanName(package, ClanName);
			ClanDataRules.WriteClanDescription(package, ClanDescription);
			ClanDataRules.WriteClanEmblemKey(package, ClanEmblemKey);
			package.Write((int)ClanDataRules.RequireEnum(SelfRole, "self role"));
			ClanDataRules.WriteOptionalClanId(package, PrimaryClanId, "primary clan id");
			ClanDataRules.WriteOptionalClanName(package, PrimaryClanName, "primary clan name");
			package.Write((int)ClanDataRules.RequireEnum(PrimaryRole, "primary clan role"));
			ClanDataRules.WriteOptionalClanId(package, GuestClanId, "guest clan id");
			ClanDataRules.WriteOptionalClanName(package, GuestClanName, "guest clan name");
			package.Write(Roster.Count);
			foreach (ClanPlayerSummary item in Roster)
			{
				item.Write(package);
			}
			package.Write(Applications.Count);
			foreach (ClanApplicationSummary application in Applications)
			{
				application.Write(package);
			}
			package.Write(Invite != null);
			Invite?.Write(package);
			package.Write(HasOwnApplication);
			if (HasOwnApplication)
			{
				ClanDataRules.WriteClanId(package, OwnApplicationClanId, "own application clan id");
				ClanDataRules.WriteClanName(package, OwnApplicationClanName, "own application clan name");
			}
		}

		public static ClanClientSnapshot Read(ZPackage package)
		{
			ClanClientSnapshot clanClientSnapshot = new ClanClientSnapshot
			{
				Status = ClanDataRules.ReadText(package, 1024, "snapshot status", allowEmpty: true, allowLineBreaks: true),
				ResponseRequestId = ClanDataRules.RequireOptionalRequestId(package.ReadLong()),
				ResponseResultCode = ClanDataRules.ReadEnum<ClanOperationResultCode>(package, "operation result"),
				ClanId = ClanDataRules.ReadOptionalClanId(package),
				ClanName = ClanDataRules.ReadOptionalClanName(package),
				ClanDescription = ClanDataRules.ReadClanDescription(package),
				ClanEmblemKey = ClanDataRules.ReadClanEmblemKey(package),
				SelfRole = ClanDataRules.ReadEnum<ClanRole>(package, "self role"),
				PrimaryClanId = ClanDataRules.ReadOptionalClanId(package, "primary clan id"),
				PrimaryClanName = ClanDataRules.ReadOptionalClanName(package, "primary clan name"),
				PrimaryRole = ClanDataRules.ReadEnum<ClanRole>(package, "primary clan role"),
				GuestClanId = ClanDataRules.ReadOptionalClanId(package, "guest clan id"),
				GuestClanName = ClanDataRules.ReadOptionalClanName(package, "guest clan name")
			};
			ReadList(package, clanClientSnapshot.Roster, 512, "roster", ClanPlayerSummary.Read);
			ReadList(package, clanClientSnapshot.Applications, 512, "application", ClanApplicationSummary.Read);
			if (package.ReadBool())
			{
				clanClientSnapshot.Invite = ClanInviteSummary.Read(package);
			}
			if (package.ReadBool())
			{
				clanClientSnapshot.OwnApplicationClanId = ClanDataRules.ReadClanId(package, "own application clan id");
				clanClientSnapshot.OwnApplicationClanName = ClanDataRules.ReadClanName(package, "own application clan name");
			}
			return clanClientSnapshot;
		}

		public bool ContainsClanPlayer(ClanPlayerRef player)
		{
			if (!player.IsValid)
			{
				return false;
			}
			foreach (ClanPlayerSummary item in Roster)
			{
				if (item.IsOnline && StringComparer.Ordinal.Equals(item.Id, player.Id))
				{
					return true;
				}
			}
			return false;
		}

		private static void ReadList<T>(ZPackage package, List<T> items, int maximum, string fieldName, Func<ZPackage, T> read)
		{
			int num = ClanDataRules.ReadCount(package, maximum, fieldName);
			for (int i = 0; i < num; i++)
			{
				items.Add(read(package));
			}
		}
	}
	internal sealed class ClanDirectoryPlayerSummary
	{
		public string PlayerId = "";

		public string PlayerName = "";

		public ClanDirectoryPlayerState State;

		public string ClanName = "";

		public bool IsOnline;

		public bool IsSelf;

		public bool CanInvite;

		public bool CanResolveApplication;

		public long LastSeenUtcTicks;

		public void Write(ZPackage package)
		{
			ClanDataRules.WritePlayerKey(package, PlayerId, "directory player key");
			ClanDataRules.WritePlayerName(package, PlayerName, "directory player name");
			package.Write((int)ClanDataRules.RequireEnum(State, "directory player state"));
			ClanDataRules.WriteOptionalClanName(package, ClanName, "directory clan name");
			package.Write(IsOnline);
			package.Write(IsSelf);
			package.Write(CanInvite);
			package.Write(CanResolveApplication);
			if (LastSeenUtcTicks >= 0)
			{
				long lastSeenUtcTicks = LastSeenUtcTicks;
				DateTime maxValue = DateTime.MaxValue;
				if (lastSeenUtcTicks <= maxValue.Ticks)
				{
					package.Write(LastSeenUtcTicks);
					return;
				}
			}
			throw new InvalidDataException("directory last-seen timestamp is invalid.");
		}

		public static ClanDirectoryPlayerSummary Read(ZPackage package)
		{
			ClanDirectoryPlayerSummary clanDirectoryPlayerSummary = new ClanDirectoryPlayerSummary
			{
				PlayerId = ClanDataRules.ReadPlayerKey(package, "directory player key"),
				PlayerName = ClanDataRules.ReadPlayerName(package, "directory player name"),
				State = ClanDataRules.ReadEnum<ClanDirectoryPlayerState>(package, "directory player state"),
				ClanName = ClanDataRules.ReadOptionalClanName(package, "directory clan name"),
				IsOnline = package.ReadBool(),
				IsSelf = package.ReadBool(),
				CanInvite = package.ReadBool(),
				CanResolveApplication = package.ReadBool()
			};
			clanDirectoryPlayerSummary.LastSeenUtcTicks = package.ReadLong();
			if (clanDirectoryPlayerSummary.LastSeenUtcTicks >= 0)
			{
				long lastSeenUtcTicks = clanDirectoryPlayerSummary.LastSeenUtcTicks;
				DateTime maxValue = DateTime.MaxValue;
				if (lastSeenUtcTicks <= maxValue.Ticks)
				{
					return clanDirectoryPlayerSummary;
				}
			}
			throw new InvalidDataException("directory last-seen timestamp is invalid.");
		}
	}
	internal sealed class ClanDirectorySnapshot
	{
		public long RequestId;

		public ClanOperationResultCode ResultCode;

		public string Status = "";

		public bool IsTruncated;

		public readonly List<ClanPublicSummary> PublicClans = new List<ClanPublicSummary>();

		public readonly List<ClanDirectoryPlayerSummary> Players = new List<ClanDirectoryPlayerSummary>();

		internal void Write(ZPackage package, int publicClanCount, int playerCount)
		{
			publicClanCount = ClanDataRules.RequireRange(publicClanCount, 0, Math.Min(PublicClans.Count, 1024), "directory clan count");
			playerCount = ClanDataRules.RequireRange(playerCount, 0, Math.Min(Players.Count, 1024), "directory player count");
			package.Write(ClanDataRules.RequireRequestId(RequestId));
			package.Write((int)ClanDataRules.RequireEnum(ResultCode, "directory result"));
			ClanDataRules.WriteText(package, Status, 1024, "directory status", allowEmpty: true, allowLineBreaks: true);
			package.Write(IsTruncated);
			package.Write(publicClanCount);
			for (int i = 0; i < publicClanCount; i++)
			{
				PublicClans[i].Write(package);
			}
			package.Write(playerCount);
			for (int j = 0; j < playerCount; j++)
			{
				Players[j].Write(package);
			}
		}

		public static ClanDirectorySnapshot Read(ZPackage package)
		{
			ClanDirectorySnapshot clanDirectorySnapshot = new ClanDirectorySnapshot
			{
				RequestId = ClanDataRules.RequireRequestId(package.ReadLong()),
				ResultCode = ClanDataRules.ReadEnum<ClanOperationResultCode>(package, "directory result"),
				Status = ClanDataRules.ReadText(package, 1024, "directory status", allowEmpty: true, allowLineBreaks: true),
				IsTruncated = package.ReadBool()
			};
			int num = ClanDataRules.ReadCount(package, 1024, "directory clan");
			for (int i = 0; i < num; i++)
			{
				clanDirectorySnapshot.PublicClans.Add(ClanPublicSummary.Read(package));
			}
			int num2 = ClanDataRules.ReadCount(package, 1024, "directory player");
			for (int j = 0; j < num2; j++)
			{
				clanDirectorySnapshot.Players.Add(ClanDirectoryPlayerSummary.Read(package));
			}
			return clanDirectorySnapshot;
		}
	}
	internal static class ClanLocalizationManager
	{
		private static readonly string[] SupportedExtensions = new string[2] { ".yml", ".json" };

		private const long MaximumExternalTranslationBytes = 1048576L;

		private const int MaximumTranslationValueLength = 4096;

		private static readonly object Sync = new object();

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

		private static BaseUnityPlugin? _plugin;

		private static ManualLogSource? _logger;

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

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

		private static string _currentLanguage = "English";

		private static bool _hasLoadedLanguage;

		private static bool _initialized;

		internal static event Action? LanguageChanged;

		internal static void Initialize(BaseUnityPlugin plugin, Harmony harmony)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			if (!_initialized)
			{
				_plugin = plugin;
				_logger = ClanPlugin.ClanLogger;
				_embeddedEnglish = LoadEmbeddedTranslation("English") ?? throw new InvalidOperationException(plugin.Info.Metadata.Name + " has no embedded translations/English.yml or translations/English.json resource.");
				_currentTexts = new Dictionary<string, string>(_embeddedEnglish, StringComparer.Ordinal);
				_initialized = true;
				harmony.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "SetupLanguage", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(ClanLocalizationManager), "AfterSetupLanguage", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "SetupGui", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(ClanLocalizationManager), "AfterSetupGui", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Localization instance = Localization.instance;
				if (instance != null)
				{
					Reload(SafeSelectedLanguage(instance));
				}
			}
		}

		internal static void Dispose()
		{
			lock (Sync)
			{
				_plugin = null;
				_logger = null;
				_embeddedEnglish = new Dictionary<string, string>(StringComparer.Ordinal);
				_currentTexts = new Dictionary<string, string>(StringComparer.Ordinal);
				_currentLanguage = "English";
				_hasLoadedLanguage = false;
				LoggedWarnings.Clear();
				ClanLocalizationManager.LanguageChanged = null;
				_initialized = false;
			}
		}

		internal static string GetText(string key)
		{
			string text = NormalizeKey(key);
			lock (Sync)
			{
				if (_currentTexts.TryGetValue(text, out string value))
				{
					return value;
				}
				if (_embeddedEnglish.TryGetValue(text, out string value2))
				{
					return value2;
				}
			}
			WarnOnce("missing:" + text, "Missing Clan localization key '" + text + "'.");
			return text;
		}

		private static void AfterSetupLanguage(string language)
		{
			Reload(language);
		}

		private static void AfterSetupGui()
		{
			Localization instance = Localization.instance;
			if (instance != null && NeedsReload(SafeSelectedLanguage(instance)))
			{
				Reload(SafeSelectedLanguage(instance));
			}
		}

		private static bool NeedsReload(string language)
		{
			lock (Sync)
			{
				return !_hasLoadedLanguage || !_currentLanguage.Equals(language, StringComparison.OrdinalIgnoreCase);
			}
		}

		private static void Reload(string language)
		{
			if (!_initialized || (Object)(object)_plugin == (Object)null)
			{
				return;
			}
			string text = (string.IsNullOrWhiteSpace(language) ? "English" : language.Trim());
			Dictionary<string, List<string>> externalFiles = FindExternalTranslations();
			Dictionary<string, string> dictionary = new Dictionary<string, string>(_embeddedEnglish, StringComparer.Ordinal);
			MergeExternalTranslation(dictionary, externalFiles, "English");
			if (!text.Equals("English", StringComparison.OrdinalIgnoreCase))
			{
				Dictionary<string, string> dictionary2 = LoadEmbeddedTranslation(text);
				if (dictionary2 != null)
				{
					Merge(dictionary, ValidateTranslation("embedded " + text + " translation", dictionary2));
				}
				MergeExternalTranslation(dictionary, externalFiles, text);
			}
			lock (Sync)
			{
				_currentTexts = dictionary;
				_currentLanguage = text;
				_hasLoadedLanguage = true;
			}
			InvokeLanguageChanged();
		}

		private static Dictionary<string, List<string>> FindExternalTranslations()
		{
			BaseUnityPlugin plugin = _plugin;
			if ((Object)(object)plugin == (Object)null)
			{
				return new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
			}
			string name = plugin.Info.Metadata.Name;
			string text = Directory.GetParent(Paths.PluginPath)?.FullName;
			if (string.IsNullOrWhiteSpace(text) || !Directory.Exists(text))
			{
				WarnOnce("missing-bepinex-root", "Could not locate the BepInEx root while searching for Clan translations.");
				return new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
			}
			Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
			foreach (string item in EnumerateFilesSafely(text))
			{
				string extension = Path.GetExtension(item);
				if (!SupportedExtensions.Contains<string>(extension, StringComparer.OrdinalIgnoreCase))
				{
					continue;
				}
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item);
				string text2 = name + ".";
				if (fileNameWithoutExtension.StartsWith(text2, StringComparison.OrdinalIgnoreCase) && fileNameWithoutExtension.Length != text2.Length)
				{
					string key = fileNameWithoutExtension.Substring(text2.Length);
					if (!dictionary.TryGetValue(key, out var value))
					{
						value = (dictionary[key] = new List<string>());
					}
					value.Add(item);
				}
			}
			foreach (List<string> value2 in dictionary.Values)
			{
				value2.Sort(CompareExternalCandidates);
			}
			return dictionary;
		}

		private static IEnumerable<string> EnumerateFilesSafely(string root)
		{
			Stack<string> pending = new Stack<string>();
			pending.Push(Path.GetFullPath(root));
			while (pending.Count > 0)
			{
				string directory = pending.Pop();
				string[] files;
				try
				{
					files = Directory.GetFiles(directory);
				}
				catch (Exception ex) when (((ex is IOException || ex is UnauthorizedAccessException) ? 1 : 0) != 0)
				{
					WarnOnce("scan-files:" + directory, "Could not scan '" + directory + "' for Clan translations: " + ex.Message);
					continue;
				}
				Array.Sort(files, (IComparer<string>?)StringComparer.OrdinalIgnoreCase);
				string[] array = files;
				for (int i = 0; i < array.Length; i++)
				{
					yield return array[i];
				}
				string[] directories;
				try
				{
					directories = Directory.GetDirectories(directory);
				}
				catch (Exception ex2) when (((ex2 is IOException || ex2 is UnauthorizedAccessException) ? 1 : 0) != 0)
				{
					WarnOnce("scan-directories:" + directory, "Could not scan subdirectories of '" + directory + "' for Clan translations: " + ex2.Message);
					continue;
				}
				Array.Sort(directories, (IComparer<string>?)StringComparer.OrdinalIgnoreCase);
				for (int num = directories.Length - 1; num >= 0; num--)
				{
					string text = directories[num];
					try
					{
						if ((File.GetAttributes(text) & FileAttributes.ReparsePoint) == 0)
						{
							pending.Push(text);
						}
					}
					catch (Exception ex3) when (((ex3 is IOException || ex3 is UnauthorizedAccessException) ? 1 : 0) != 0)
					{
						WarnOnce("scan-attributes:" + text, "Could not inspect '" + text + "' while searching for Clan translations: " + ex3.Message);
					}
				}
			}
		}

		private static int CompareExternalCandidates(string left, string right)
		{
			int num = IsUnderDirectory(left, Paths.ConfigPath).CompareTo(IsUnderDirectory(right, Paths.ConfigPath));
			if (num != 0)
			{
				return -num;
			}
			int num2 = ExtensionPriority(left).CompareTo(ExtensionPriority(right));
			if (num2 == 0)
			{
				return StringComparer.OrdinalIgnoreCase.Compare(Path.GetFullPath(left), Path.GetFullPath(right));
			}
			return num2;
		}

		private static int ExtensionPriority(string path)
		{
			return (!Path.GetExtension(path).Equals(".yml", StringComparison.OrdinalIgnoreCase)) ? 1 : 0;
		}

		private static bool IsUnderDirectory(string path, string directory)
		{
			string fullPath = Path.GetFullPath(path);
			string text = Path.GetFullPath(directory).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			string value = text + directorySeparatorChar;
			return fullPath.StartsWith(value, StringComparison.OrdinalIgnoreCase);
		}

		private static void MergeExternalTranslation(IDictionary<string, string> target, IReadOnlyDictionary<string, List<string>> externalFiles, string language)
		{
			if (!externalFiles.TryGetValue(language, out List<string> value))
			{
				return;
			}
			for (int i = 0; i < value.Count; i++)
			{
				string text = value[i];
				Dictionary<string, string> dictionary = TryLoadExternalTranslation(text);
				if (dictionary != null)
				{
					Merge(target, dictionary);
					for (int j = i + 1; j < value.Count; j++)
					{
						WarnOnce("duplicate:" + language + ":" + value[j], "Ignoring duplicate Clan " + language + " translation '" + value[j] + "'; using '" + text + "'.");
					}
					break;
				}
			}
		}

		private static Dictionary<string, string>? TryLoadExternalTranslation(string path)
		{
			try
			{
				long length = new FileInfo(path).Length;
				if (length <= 0 || length > 1048576)
				{
					throw new InvalidDataException($"translation size must be between 1 and {1048576L} bytes");
				}
				Dictionary<string, string> dictionary = ParseTranslation(File.ReadAllText(path, Encoding.UTF8));
				if (dictionary == null || dictionary.Count == 0)
				{
					throw new InvalidDataException("the translation file is empty");
				}
				dictionary = ValidateTranslation(path, dictionary);
				if (dictionary.Count == 0)
				{
					throw new InvalidDataException("the translation file has no valid Clan keys");
				}
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)("Loaded external Clan translation '" + path + "'."));
				}
				return dictionary;
			}
			catch (Exception ex)
			{
				WarnOnce("external:" + path + ":" + ex.GetType().FullName + ":" + ex.Message, "Could not load external Clan translation '" + path + "': " + ex.Message + ". Falling back to the next valid source.");
				return null;
			}
		}

		private static Dictionary<string, string> ValidateTranslation(string source, IReadOnlyDictionary<string, string> translation)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			foreach (KeyValuePair<string, string> item in translation)
			{
				if (!_embeddedEnglish.TryGetValue(item.Key, out string value))
				{
					WarnOnce("unknown-key:" + source + ":" + item.Key, "Ignored unknown Clan translation key '" + item.Key + "' in '" + source + "'.");
				}
				else if (item.Value.Length > 4096)
				{
					WarnOnce("long-value:" + source + ":" + item.Key, $"Ignored Clan translation key '{item.Key}' in '{source}' because its value exceeds {4096} characters.");
				}
				else if (!HasCompatiblePlaceholders(value, item.Value))
				{
					WarnOnce("placeholders:" + source + ":" + item.Key, "Ignored Clan translation key '" + item.Key + "' in '" + source + "' because its format placeholders do not match English.");
				}
				else
				{
					dictionary[item.Key] = item.Value;
				}
			}
			return dictionary;
		}

		private static bool HasCompatiblePlaceholders(string english, string candidate)
		{
			if (TryReadPlaceholderIndexes(english, out HashSet<int> indexes) && TryReadPlaceholderIndexes(candidate, out HashSet<int> indexes2))
			{
				return indexes.SetEquals(indexes2);
			}
			return false;
		}

		private static bool TryReadPlaceholderIndexes(string template, out HashSet<int> indexes)
		{
			indexes = new HashSet<int>();
			int num = 0;
			while (num < template.Length)
			{
				switch (template[num])
				{
				case '{':
				{
					if (num + 1 < template.Length && template[num + 1] == '{')
					{
						num += 2;
						break;
					}
					int num2 = template.IndexOf('}', num + 1);
					if (num2 < 0 || !int.TryParse(template.Substring(num + 1, num2 - num - 1), NumberStyles.None, CultureInfo.InvariantCulture, out var result))
					{
						return false;
					}
					indexes.Add(result);
					num = num2 + 1;
					break;
				}
				case '}':
					if (num + 1 >= template.Length || template[num + 1] != '}')
					{
						return false;
					}
					num += 2;
					break;
				default:
					num++;
					break;
				}
			}
			return true;
		}

		private static Dictionary<string, string>? LoadEmbeddedTranslation(string language)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string[] supportedExtensions = SupportedExtensions;
			foreach (string text in supportedExtensions)
			{
				string suffix = "translations." + language + text;
				string text2 = executingAssembly.GetManifestResourceNames().OrderBy<string, string>((string name) => name, StringComparer.Ordinal).FirstOrDefault((string name) => name.EndsWith(suffix, StringComparison.OrdinalIgnoreCase));
				if (text2 == null)
				{
					continue;
				}
				using Stream stream = executingAssembly.GetManifestResourceStream(text2);
				if (stream == null)
				{
					continue;
				}
				using StreamReader streamReader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true);
				return ParseTranslation(streamReader.ReadToEnd());
			}
			return null;
		}

		private static Dictionary<string, string>? ParseTranslation(string data)
		{
			Dictionary<string, string> dictionary = new DeserializerBuilder().IgnoreFields().WithDuplicateKeyChecking().Build()
				.Deserialize<Dictionary<string, string>>(data);
			if (dictionary == null)
			{
				return null;
			}
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>(StringComparer.Ordinal);
			foreach (KeyValuePair<string, string> item in dictionary)
			{
				string text = NormalizeKey(item.Key);
				if (!string.IsNullOrWhiteSpace(text) && item.Value != null)
				{
					dictionary2[text] = item.Value;
				}
			}
			return dictionary2;
		}

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

		private static string SafeSelectedLanguage(Localization localization)
		{
			try
			{
				return localization.GetSelectedLanguage();
			}
			catch (Exception ex)
			{
				WarnOnce("selected-language", "Could not read the selected language: " + ex.Message + ". Using English.");
				return _currentLanguage;
			}
		}

		private static string NormalizeKey(string key)
		{
			return (key ?? string.Empty).Trim().TrimStart(new char[1] { '$' });
		}

		private static void InvokeLanguageChanged()
		{
			Delegate[] array = ClanLocalizationManager.LanguageChanged?.GetInvocationList() ?? Array.Empty<Delegate>();
			foreach (Delegate obj in array)
			{
				try
				{
					((Action)obj)();
				}
				catch (Exception ex)
				{
					ManualLogSource? logger = _logger;
					if (logger != null)
					{
						logger.LogWarning((object)("Clan language-change subscriber failed: " + ex.GetBaseException().Message));
					}
				}
			}
		}

		private static void WarnOnce(string identity, string message)
		{
			lock (Sync)
			{
				if (!LoggedWarnings.Add(identity))
				{
					return;
				}
			}
			ManualLogSource? logger = _logger;
			if (logger != null)
			{
				logger.LogWarning((object)message);
			}
		}
	}
	internal static class ClanLocalization
	{
		private const string WireStatusPrefix = "@ClanL10n1:";

		private const int MaximumWireStatusLength = 1024;

		private const int MaximumWireArgumentCount = 8;

		private const int MaximumWireArgumentUtf8Bytes = 256;

		private static readonly UTF8Encoding StrictUtf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

		private static bool _malformedWireStatusLogged;

		internal static event Action? LanguageChanged
		{
			add
			{
				ClanLocalizationManager.LanguageChanged += value;
			}
			remove
			{
				ClanLocalizationManager.LanguageChanged -= value;
			}
		}

		internal static void Initialize(BaseUnityPlugin plugin, Harmony harmony)
		{
			ClanLocalizationManager.Initialize(plugin, harmony);
		}

		internal static void Dispose()
		{
			ClanLocalizationManager.Dispose();
		}

		internal static string Text(string key)
		{
			return ClanLocalizationManager.GetText(key);
		}

		internal static string Format(string key, params object[] arguments)
		{
			string text = Text(key);
			try
			{
				return string.Format(CultureInfo.CurrentCulture, text, arguments);
			}
			catch (FormatException ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Invalid format string for Clan localization key '" + key + "': " + ex.Message));
				return text;
			}
		}

		internal static string EncodeStatus(string key, params object[] arguments)
		{
			string text = (key ?? string.Empty).Trim().TrimStart(new char[1] { '$' });
			if (text.Length == 0)
			{
				return string.Empty;
			}
			if (text.Length > 96 || !IsSafeWireKey(text))
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Refused to encode invalid Clan status localization key '" + text + "'."));
				return text;
			}
			object[] array = arguments ?? Array.Empty<object>();
			int num = Math.Min(array.Length, 8);
			StringBuilder stringBuilder = new StringBuilder("@ClanL10n1:".Length + text.Length + num * 24);
			stringBuilder.Append("@ClanL10n1:").Append(text);
			for (int i = 0; i < num; i++)
			{
				string s = LimitUtf8(Convert.ToString(array[i], CultureInfo.InvariantCulture) ?? string.Empty, 256);
				stringBuilder.Append('|').Append(Convert.ToBase64String(Encoding.UTF8.GetBytes(s)));
			}
			if (stringBuilder.Length <= 1024)
			{
				return stringBuilder.ToString();
			}
			ClanPlugin.ClanLogger.LogWarning((object)("Clan status localization payload for '" + text + "' exceeded its wire limit."));
			return "@ClanL10n1:" + text;
		}

		internal static string ResolveStatus(string value)
		{
			if (string.IsNullOrEmpty(value) || !value.StartsWith("@ClanL10n1:", StringComparison.Ordinal))
			{
				return value ?? string.Empty;
			}
			try
			{
				if (value.Length > 1024)
				{
					throw new FormatException("status payload exceeds its wire limit");
				}
				string[] array = value.Substring("@ClanL10n1:".Length).Split(new char[1] { '|' });
				if (array.Length == 0 || array.Length > 9 || array[0].Length == 0 || array[0].Length > 96 || !IsSafeWireKey(array[0]))
				{
					throw new FormatException("status payload contains an invalid localization key or argument count");
				}
				if (array.Length == 1)
				{
					return Text(array[0]);
				}
				List<object> list = new List<object>(array.Length - 1);
				for (int i = 1; i < array.Length; i++)
				{
					byte[] array2 = Convert.FromBase64String(array[i]);
					if (array2.Length > 256)
					{
						throw new FormatException("status argument exceeds its wire limit");
					}
					list.Add(StrictUtf8.GetString(array2));
				}
				return Format(array[0], list.ToArray());
			}
			catch (Exception ex) when (((ex is FormatException || ex is DecoderFallbackException) ? 1 : 0) != 0)
			{
				if (!_malformedWireStatusLogged)
				{
					_malformedWireStatusLogged = true;
					ClanPlugin.ClanLogger.LogWarning((object)("Ignored a malformed localized Clan status payload: " + ex.Message));
				}
				return Text("clan_status_unavailable");
			}
		}

		internal static string Role(ClanRole role)
		{
			return role switch
			{
				ClanRole.Leader => Text("clan_role_leader"), 
				ClanRole.Officer => Text("clan_role_officer"), 
				ClanRole.Member => Text("clan_role_member"), 
				ClanRole.Guest => Text("clan_role_guest"), 
				_ => role.ToString(), 
			};
		}

		private static bool IsSafeWireKey(string key)
		{
			foreach (char c in key)
			{
				if ((c < 'a' || c > 'z') && (c < '0' || c > '9') && c != '_' && c != '-' && c != '.')
				{
					return false;
				}
			}
			return true;
		}

		private static string LimitUtf8(string value, int maximumBytes)
		{
			if (Encoding.UTF8.GetByteCount(value) <= maximumBytes)
			{
				return value;
			}
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			int num = 0;
			int num2;
			for (num2 = 0; num2 < value.Length; num2++)
			{
				int num3 = ((!char.IsHighSurrogate(value[num2]) || num2 + 1 >= value.Length || !char.IsLowSurrogate(value[num2 + 1])) ? 1 : 2);
				string text = value.Substring(num2, num3);
				int byteCount = Encoding.UTF8.GetByteCount(text);
				if (num + byteCount > maximumBytes)
				{
					break;
				}
				stringBuilder.Append(text);
				num += byteCount;
				num2 += num3 - 1;
			}
			return stringBuilder.ToString();
		}
	}
	public enum ClanWardAuthorizationResolution
	{
		Unavailable,
		ResolvedNoAuthorization,
		Authorized
	}
	public enum ClanMembershipResolution
	{
		Unavailable,
		Resolved
	}
	public sealed class ClanInfo
	{
		public string ClanId { get; }

		public string Name { get; }

		public string Description { get; }

		public string EmblemKey { get; }

		public string LeaderName { get; }

		public int MemberCount { get; }

		internal ClanInfo(string clanId, string name, string description, string emblemKey, string leaderName, int memberCount)
		{
			ClanId = clanId;
			Name = name;
			Description = description;
			EmblemKey = emblemKey;
			LeaderName = leaderName;
			MemberCount = memberCount;
		}
	}
	public sealed class ClanMemberInfo
	{
		public string PlayerKey { get; }

		public string PlatformId { get; }

		public long PlayerId { get; }

		public string Name { get; }

		public ClanRole Role { get; }

		public bool IsSelf { get; }

		public bool IsOnline { get; }

		internal ClanMemberInfo(ClanPlayerSummary source)
		{
			PlayerKey = source.Player.Id;
			PlatformId = source.Player.PlatformId;
			PlayerId = source.Player.CharacterPlayerId;
			Name = source.Player.Name;
			Role = source.Role;
			IsSelf = source.IsSelf;
			IsOnline = source.IsOnline;
		}
	}
	public sealed class ClanLocalSnapshot
	{
		private static readonly IReadOnlyList<ClanMemberInfo> NoMembers = new ReadOnlyCollection<ClanMemberInfo>(Array.Empty<ClanMemberInfo>());

		public bool IsReady { get; }

		public bool HasClan => Clan != null;

		public bool HasPrimaryClan => !string.IsNullOrWhiteSpace(PrimaryClanId);

		public bool HasGuestClan => !string.IsNullOrWhiteSpace(GuestClanId);

		public bool HasAnyClan
		{
			get
			{
				if (!HasPrimaryClan)
				{
					return HasGuestClan;
				}
				return true;
			}
		}

		public string EffectiveClanId => Clan?.ClanId ?? "";

		public string PrimaryClanId { get; }

		public string PrimaryClanName { get; }

		public ClanRole? PrimaryRole { get; }

		public string GuestClanId { get; }

		public string GuestClanName { get; }

		public ClanInfo? Clan { get; }

		public ClanRole? SelfRole { get; }

		public IReadOnlyList<ClanMemberInfo> Members { get; }

		internal static ClanLocalSnapshot Empty { get; } = new ClanLocalSnapshot(isReady: false, "", "", null, "", "", null, null, NoMembers);

		internal ClanLocalSnapshot(bool isReady, string primaryClanId, string primaryClanName, ClanRole? primaryRole, string guestClanId, string guestClanName, ClanInfo? clan, ClanRole? selfRole, IReadOnlyList<ClanMemberInfo> members)
		{
			IsReady = isReady;
			PrimaryClanId = primaryClanId ?? "";
			PrimaryClanName = primaryClanName ?? "";
			PrimaryRole = primaryRole;
			GuestClanId = guestClanId ?? "";
			GuestClanName = guestClanName ?? "";
			Clan = clan;
			SelfRole = selfRole;
			Members = members;
		}
	}
	public enum ClanRenameResultCode
	{
		Unknown,
		Success,
		Unchanged,
		InvalidName,
		NotConnected,
		IdentityUnavailable,
		NotLeader,
		ClanChanged,
		NameAlreadyExists,
		RateLimited,
		TimedOut,
		SessionEnded,
		Failed
	}
	public sealed class ClanRenameResult
	{
		public long RequestId { get; }

		public ClanRenameResultCode Code { get; }

		public bool Succeeded
		{
			get
			{
				ClanRenameResultCode code = Code;
				if ((uint)(code - 1) <= 1u)
				{
					return true;
				}
				return false;
			}
		}

		public string RequestedName { get; }

		public string Message { get; }

		public ClanLocalSnapshot State { get; }

		internal ClanRenameResult(long requestId, ClanRenameResultCode code, string requestedName, string message, ClanLocalSnapshot state)
		{
			RequestId = requestId;
			Code = code;
			RequestedName = requestedName;
			Message = message;
			State = state;
		}
	}
	public sealed class ClanRenameRequestHandle
	{
		private readonly object _gate = new object();

		private Action<ClanRenameResult>? _completed;

		private ClanRenameResult? _result;

		public long RequestId { get; }

		public bool IsCompleted
		{
			get
			{
				lock (_gate)
				{
					return _result != null;
				}
			}
		}

		public ClanRenameResult? Result
		{
			get
			{
				lock (_gate)
				{
					return _result;
				}
			}
		}

		public event Action<ClanRenameResult>? Completed
		{
			add
			{
				if (value == null)
				{
					return;
				}
				ClanRenameResult result;
				lock (_gate)
				{
					result = _result;
					if (result == null)
					{
						_completed = (Action<ClanRenameResult>)Delegate.Combine(_completed, value);
						return;
					}
				}
				InvokeSubscriber(value, result);
			}
			remove
			{
				lock (_gate)
				{
					_completed = (Action<ClanRenameResult>)Delegate.Remove(_completed, value);
				}
			}
		}

		internal ClanRenameRequestHandle(long requestId)
		{
			RequestId = requestId;
		}

		public bool TryGetResult(out ClanRenameResult? result)
		{
			lock (_gate)
			{
				result = _result;
				return result != null;
			}
		}

		internal bool Complete(ClanRenameResult result)
		{
			Action<ClanRenameResult> completed;
			lock (_gate)
			{
				if (_result != null)
				{
					return false;
				}
				_result = result;
				completed = _completed;
				_completed = null;
			}
			if (completed != null)
			{
				Delegate[] invocationList = completed.GetInvocationList();
				for (int i = 0; i < invocationList.Length; i++)
				{
					InvokeSubscriber((Action<ClanRenameResult>)invocationList[i], result);
				}
			}
			return true;
		}

		private static void InvokeSubscriber(Action<ClanRenameResult> subscriber, ClanRenameResult result)
		{
			try
			{
				subscriber(result);
			}
			catch (Exception arg)
			{
				ClanPlugin.ClanLogger.LogWarning((object)$"Clan API rename completion subscriber failed: {arg}");
			}
		}
	}
	public static class ClanApi
	{
		private sealed class PendingRename
		{
			public ClanRenameRequestHandle Handle { get; }

			public string RequestedName { get; }

			public float Deadline { get; }

			public PendingRename(ClanRenameRequestHandle handle, string requestedName, float deadline)
			{
				Handle = handle;
				RequestedName = requestedName;
				Deadline = deadline;
			}
		}

		public const int ApiVersion = 4;

		private const float RenameTimeoutSeconds = 15f;

		private static readonly object PendingLock = new object();

		private static readonly Dictionary<long, PendingRename> PendingRenames = new Dictionary<long, PendingRename>();

		private static readonly IReadOnlyList<ClanInfo> NoClans = new ReadOnlyCollection<ClanInfo>(Array.Empty<ClanInfo>());

		private static bool _initialized;

		private static long _registryRevision;

		public static ClanLocalSnapshot Current { get; private set; } = ClanLocalSnapshot.Empty;

		public static IReadOnlyList<ClanInfo> KnownClans { get; private set; } = NoClans;

		public static long RegistryRevision => Interlocked.Read(in _registryRevision);

		public static event Action<ClanLocalSnapshot>? StateChanged;

		public static event Action<IReadOnlyList<ClanInfo>>? DirectoryChanged;

		public static event Action<ClanRenameResult>? RenameCompleted;

		public static event Action? WardAuthorizationChanged;

		public static event Action? RegistryChanged;

		public static ClanWardAuthorizationResolution ResolveWardAuthorization(string platformId, long characterPlayerId, out string clanId, out string clanName)
		{
			return ClanRegistry.ResolveWardAuthorization(platformId, characterPlayerId, out clanId, out clanName);
		}

		public static ClanMembershipResolution ResolveMemberships(string platformId, long characterPlayerId, out string primaryClanId, out string primaryClanName, out string guestClanId, out string guestClanName)
		{
			return ClanRegistry.ResolveMemberships(platformId, characterPlayerId, out primaryClanId, out primaryClanName, out guestClanId, out guestClanName);
		}

		internal static void Initialize()
		{
			if (!_initialized)
			{
				_initialized = true;
				ClanRpc.SnapshotChanged += OnSnapshotChanged;
				ClanRpc.DirectoryChanged += OnDirectoryChanged;
				Current = CreateLocalSnapshot(ClanRpc.CurrentSnapshot);
				KnownClans = CreateDirectory(ClanRpc.CurrentDirectory);
			}
		}

		internal static void Dispose()
		{
			if (_initialized)
			{
				ClanRpc.SnapshotChanged -= OnSnapshotChanged;
				ClanRpc.DirectoryChanged -= OnDirectoryChanged;
				CompleteAll(ClanRenameResultCode.SessionEnded, "Clan API was shut down.");
				_initialized = false;
				Current = ClanLocalSnapshot.Empty;
				KnownClans = NoClans;
				ClanApi.StateChanged = null;
				ClanApi.DirectoryChanged = null;
				ClanApi.RenameCompleted = null;
				ClanApi.WardAuthorizationChanged = null;
				ClanApi.RegistryChanged = null;
			}
		}

		internal static void NotifyRegistryChanged()
		{
			Interlocked.Increment(ref _registryRevision);
			InvokeInvalidationSubscribers(ClanApi.WardAuthorizationChanged, "ward authorization");
			InvokeInvalidationSubscribers(ClanApi.RegistryChanged, "registry");
		}

		private static void InvokeInvalidationSubscribers(Action? subscribers, string eventName)
		{
			if (subscribers == null)
			{
				return;
			}
			Delegate[] invocationList = subscribers.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action action = (Action)invocationList[i];
				try
				{
					action();
				}
				catch (Exception arg)
				{
					ClanPlugin.ClanLogger.LogWarning((object)$"Clan API {eventName} subscriber failed: {arg}");
				}
			}
		}

		internal static void ResetSession()
		{
			ClanLocalSnapshot clanLocalSnapshot = CreateLocalSnapshot(ClanRpc.CurrentSnapshot);
			bool num = !HasSameState(Current, clanLocalSnapshot);
			Current = clanLocalSnapshot;
			if (num)
			{
				InvokeSubscribers(ClanApi.StateChanged, Current, "state");
			}
			bool num2 = KnownClans.Count != 0;
			KnownClans = NoClans;
			if (num2)
			{
				InvokeSubscribers<IReadOnlyList<ClanInfo>>(ClanApi.DirectoryChanged, KnownClans, "directory");
			}
			CompleteAll(ClanRenameResultCode.SessionEnded, "The clan session ended.");
		}

		internal static void Tick()
		{
			List<PendingRename> list = null;
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			lock (PendingLock)
			{
				foreach (PendingRename value in PendingRenames.Values)
				{
					if (realtimeSinceStartup >= value.Deadline)
					{
						if (list == null)
						{
							list = new List<PendingRename>();
						}
						list.Add(value);
					}
				}
				if (list != null)
				{
					foreach (PendingRename item in list)
					{
						PendingRenames.Remove(item.Handle.RequestId);
					}
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (PendingRename item2 in list)
			{
				Complete(item2, ClanRenameResultCode.TimedOut, "The clan rename request timed out.");
			}
		}

		public static ClanInfo? GetClan(string clanId)
		{
			if (Current.Clan != null && StringComparer.Ordinal.Equals(Current.Clan.ClanId, clanId))
			{
				return Current.Clan;
			}
			return KnownClans.FirstOrDefault((ClanInfo clan) => StringComparer.Ordinal.Equals(clan.ClanId, clanId));
		}

		public static IReadOnlyList<ClanMemberInfo>? GetMembers(string clanId)
		{
			if (Current.Clan == null || !StringComparer.Ordinal.Equals(Current.Clan.ClanId, clanId))
			{
				return null;
			}
			return Current.Members;
		}

		public static long RequestDirectoryRefresh()
		{
			return ClanRpc.RequestDirectory();
		}

		public static ClanRenameRequestHandle RequestRenameClan(string newName)
		{
			long num = ClanRpc.NextRequestId();
			ClanRenameRequestHandle clanRenameRequestHandle = new ClanRenameRequestHandle(num);
			string text;
			try
			{
				text = ClanDataRules.RequireClanName(newName);
			}
			catch (InvalidDataException ex)
			{
				CompleteLocal(clanRenameRequestHandle, ClanRenameResultCode.InvalidName, newName ?? "", ex.Message);
				return clanRenameRequestHandle;
			}
			if (!Current.IsReady)
			{
				CompleteLocal(clanRenameRequestHandle, ClanRenameResultCode.IdentityUnavailable, text, "Clan identity is not ready.");
				return clanRenameRequestHandle;
			}
			if (Current.Clan == null)
			{
				CompleteLocal(clanRenameRequestHandle, ClanRenameResultCode.ClanChanged, text, "The local character does not belong to a clan.");
				return clanRenameRequestHandle;
			}
			PendingRename pendingRename = new PendingRename(clanRenameRequestHandle, text, Time.realtimeSinceStartup + 15f);
			lock (PendingLock)
			{
				PendingRenames.Add(num, pendingRename);
			}
			if (!ClanRpc.Send(new ClanRequest
			{
				Type = ClanRequestType.RenameClan,
				RequestId = num,
				ClanId = Current.Clan.ClanId,
				ClanName = text
			}))
			{
				bool flag;
				lock (PendingLock)
				{
					flag = PendingRenames.Remove(num);
				}
				if (flag)
				{
					Complete(pendingRename, ClanRenameResultCode.NotConnected, "Clan server is not connected.");
				}
			}
			return clanRenameRequestHandle;
		}

		private static void OnSnapshotChanged(ClanClientSnapshot snapshot)
		{
			ClanLocalSnapshot clanLocalSnapshot = CreateLocalSnapshot(snapshot);
			bool num = !HasSameState(Current, clanLocalSnapshot);
			Current = clanLocalSnapshot;
			if (num)
			{
				InvokeSubscribers(ClanApi.StateChanged, Current, "state");
			}
			if (snapshot.ResponseRequestId <= 0)
			{
				return;
			}
			PendingRename value;
			lock (PendingLock)
			{
				if (!PendingRenames.TryGetValue(snapshot.ResponseRequestId, out value))
				{
					return;
				}
				PendingRenames.Remove(snapshot.ResponseRequestId);
			}
			Complete(value, MapResult(snapshot), snapshot.Status);
		}

		private static void OnDirectoryChanged(ClanDirectorySnapshot directory)
		{
			IReadOnlyList<ClanInfo> readOnlyList = CreateDirectory(directory);
			bool num = !HasSameDirectory(KnownClans, readOnlyList);
			KnownClans = readOnlyList;
			if (num)
			{
				InvokeSubscribers<IReadOnlyList<ClanInfo>>(ClanApi.DirectoryChanged, KnownClans, "directory");
			}
		}

		private static ClanLocalSnapshot CreateLocalSnapshot(ClanClientSnapshot source)
		{
			IReadOnlyList<ClanMemberInfo> members = new ReadOnlyCollection<ClanMemberInfo>(source.Roster.Select((ClanPlayerSummary member) => new ClanMemberInfo(member)).ToList());
			ClanInfo clan = null;
			if (source.HasClan)
			{
				string leaderName = source.Roster.FirstOrDefault((ClanPlayerSummary member) => member.Role == ClanRole.Leader)?.Name ?? "";
				clan = new ClanInfo(source.ClanId, source.ClanName, source.ClanDescription, source.ClanEmblemKey, leaderName, source.Roster.Count);
			}
			return new ClanLocalSnapshot(ClanRpc.IsIdentityReady, source.PrimaryClanId, source.PrimaryClanName, source.HasPrimaryClan ? new ClanRole?(source.PrimaryRole) : ((ClanRole?)null), source.GuestClanId, source.GuestClanName, clan, source.HasClan ? new ClanRole?(source.SelfRole) : ((ClanRole?)null), members);
		}

		private static IReadOnlyList<ClanInfo> CreateDirectory(ClanDirectorySnapshot source)
		{
			return new ReadOnlyCollection<ClanInfo>(source.PublicClans.Select((ClanPublicSummary clan) => new ClanInfo(clan.ClanId, clan.Name, clan.Description, clan.EmblemKey, clan.LeaderName, clan.MemberCount)).ToList());
		}

		private static ClanRenameResultCode MapResult(ClanClientSnapshot snapshot)
		{
			return snapshot.ResponseResultCode switch
			{
				ClanOperationResultCode.Success => ClanRenameResultCode.Success, 
				ClanOperationResultCode.Unchanged => ClanRenameResultCode.Unchanged, 
				ClanOperationResultCode.InvalidName => ClanRenameResultCode.InvalidName, 
				ClanOperationResultCode.IdentityUnavailable => ClanRenameResultCode.IdentityUnavailable, 
				ClanOperationResultCode.IdentityRejected => ClanRenameResultCode.IdentityUnavailable, 
				ClanOperationResultCode.Unauthorized => ClanRenameResultCode.NotLeader, 
				ClanOperationResultCode.ClanChanged => ClanRenameResultCode.ClanChanged, 
				ClanOperationResultCode.NameTaken => ClanRenameResultCode.NameAlreadyExists, 
				ClanOperationResultCode.RateLimited => ClanRenameResultCode.RateLimited, 
				ClanOperationResultCode.Unavailable => ClanRenameResultCode.Failed, 
				_ => ClanRenameResultCode.Failed, 
			};
		}

		private static void CompleteLocal(ClanRenameRequestHandle handle, ClanRenameResultCode code, string requestedName, string message)
		{
			ClanRenameResult clanRenameResult = new ClanRenameResult(handle.RequestId, code, requestedName, message, Current);
			if (handle.Complete(clanRenameResult))
			{
				InvokeSubscribers(ClanApi.RenameCompleted, clanRenameResult, "rename completion");
			}
		}

		private static void Complete(PendingRename pending, ClanRenameResultCode code, string message)
		{
			CompleteLocal(pending.Handle, code, pending.RequestedName, message);
		}

		private static void CompleteAll(ClanRenameResultCode code, string message)
		{
			PendingRename[] array;
			lock (PendingLock)
			{
				array = PendingRenames.Values.ToArray();
				PendingRenames.Clear();
			}
			PendingRename[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				Complete(array2[i], code, message);
			}
		}

		private static bool HasSameState(ClanLocalSnapshot left, ClanLocalSnapshot right)
		{
			if (left.IsReady != right.IsReady || !StringComparer.Ordinal.Equals(left.PrimaryClanId, right.PrimaryClanId) || !StringComparer.Ordinal.Equals(left.PrimaryClanName, right.PrimaryClanName) || left.PrimaryRole != right.PrimaryRole || !StringComparer.Ordinal.Equals(left.GuestClanId, right.GuestClanId) || !StringComparer.Ordinal.Equals(left.GuestClanName, right.GuestClanName) || left.SelfRole != right.SelfRole || !HasSameClan(left.Clan, right.Clan) || left.Members.Count != right.Members.Count)
			{
				return false;
			}
			for (int i = 0; i < left.Members.Count; i++)
			{
				ClanMemberInfo clanMemberInfo = left.Members[i];
				ClanMemberInfo clanMemberInfo2 = right.Members[i];
				if (!StringComparer.Ordinal.Equals(clanMemberInfo.PlayerKey, clanMemberInfo2.PlayerKey) || !StringComparer.Ordinal.Equals(clanMemberInfo.Name, clanMemberInfo2.Name) || clanMemberInfo.Role != clanMemberInfo2.Role || clanMemberInfo.IsSelf != clanMemberInfo2.IsSelf || clanMemberInfo.IsOnline != clanMemberInfo2.IsOnline)
				{
					return false;
				}
			}
			return true;
		}

		private static bool HasSameDirectory(IReadOnlyList<ClanInfo> left, IReadOnlyList<ClanInfo> right)
		{
			if (left.Count != right.Count)
			{
				return false;
			}
			for (int i = 0; i < left.Count; i++)
			{
				if (!HasSameClan(left[i], right[i]))
				{
					return false;
				}
			}
			return true;
		}

		private static bool HasSameClan(ClanInfo? left, ClanInfo? right)
		{
			if (left == right)
			{
				return true;
			}
			if (left != null && right != null && StringComparer.Ordinal.Equals(left.ClanId, right.ClanId) && StringComparer.Ordinal.Equals(left.Name, right.Name) && StringComparer.Ordinal.Equals(left.Description, right.Description) && StringComparer.Ordinal.Equals(left.EmblemKey, right.EmblemKey) && StringComparer.Ordinal.Equals(left.LeaderName, right.LeaderName))
			{
				return left.MemberCount == right.MemberCount;
			}
			return false;
		}

		private static void InvokeSubscribers<T>(Action<T>? subscribers, T value, string eventName)
		{
			if (subscribers == null)
			{
				return;
			}
			Delegate[] invocationList = subscribers.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action<T> action = (Action<T>)invocationList[i];
				try
				{
					action(value);
				}
				catch (Exception arg)
				{
					ClanPlugin.ClanLogger.LogWarning((object)$"Clan API {eventName} subscriber failed: {arg}");
				}
			}
		}
	}
	internal static class ClanIdentity
	{
		private static readonly Platform SteamPlatform = new Platform("Steam");

		public static ClanPlayerRef FromPeer(ZNetPeer? peer)
		{
			bool retryable;
			return FromPeer(peer, out retryable);
		}

		public static ClanPlayerRef FromPeer(ZNetPeer? peer, out bool retryable)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			retryable = true;
			if (peer == null)
			{
				ClanPlayerRef result = ClanPlayerRef.Local();
				retryable = !result.IsValid;
				return result;
			}
			if (!peer.IsReady() || ((ZDOID)(ref peer.m_characterID)).IsNone() || (Object)(object)ZNet.instance == (Object)null)
			{
				return default(ClanPlayerRef);
			}
			if (((ZDOID)(ref peer.m_characterID)).UserID != peer.m_uid)
			{
				retryable = false;
				return default(ClanPlayerRef);
			}
			string text = ResolvePeerPlatformId(peer);
			if (string.IsNullOrWhiteSpace(text))
			{
				return default(ClanPlayerRef);
			}
			long playerId = ReadCharacterPlayerId(peer.m_characterID);
			ClanPlayerRef result2 = new ClanPlayerRef(text, playerId, peer.m_playerName);
			retryable = !result2.IsValid;
			return result2;
		}

		public static ClanPlayerRef FromPlayer(Player player)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null))
			{
				return FromCharacterId(((Character)player).GetZDOID());
			}
			return default(ClanPlayerRef);
		}

		public unsafe static ClanPlayerRef FromPlayerInfo(PlayerInfo info)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (((ZDOID)(ref info.m_characterID)).IsNone())
			{
				return default(ClanPlayerRef);
			}
			return new ClanPlayerRef(((object)(*(PlatformUserID*)(&info.m_userInfo.m_id))/*cast due to .constrained prefix*/).ToString(), ReadCharacterPlayerId(info.m_characterID), info.m_name);
		}

		public unsafe static bool TryMatchRosterPlayer(PlayerInfo info, IReadOnlyList<ClanPlayerSummary> roster, out ClanPlayerRef player)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			player = default(ClanPlayerRef);
			ClanPlayerRef exact = FromPlayerInfo(info);
			if (exact.IsValid && roster.Any((ClanPlayerSummary member) => member.Id == exact.Id))
			{
				player = exact;
				return true;
			}
			string text = ClanDataRules.NormalizePlatformId(((object)(*(PlatformUserID*)(&info.m_userInfo.m_id))/*cast due to .constrained prefix*/).ToString());
			if (text.Length == 0)
			{
				return false;
			}
			ClanPlayerRef clanPlayerRef = default(ClanPlayerRef);
			int num = 0;
			foreach (ClanPlayerSummary item in roster)
			{
				if (item.Player.IsValid && StringComparer.Ordinal.Equals(item.Player.PlatformId, text) && item.IsOnline)
				{
					num++;
					clanPlayerRef = item.Player;
				}
			}
			if (num == 1)
			{
				player = clanPlayerRef;
				return true;
			}
			return false;
		}

		public static ZNetPeer? FindPeer(ClanPlayerRef player)
		{
			if (!player.IsValid)
			{
				return null;
			}
			foreach (ZNetPeer connectedPeer in GetConnectedPeers())
			{
				ClanPlayerRef player2;
				ClanPlayerRef clanPlayerRef = (ClanRpc.TryGetPinnedPeerIdentity(connectedPeer, out player2) ? player2 : FromPeer(connectedPeer));
				if (clanPlayerRef.IsValid && StringComparer.Ordinal.Equals(clanPlayerRef.Id, player.Id))
				{
					return connectedPeer;
				}
			}
			return null;
		}

		public static IEnumerable<ClanPlayerRef> GetOnlinePlayerRefs()
		{
			HashSet<string> yieldedPlayerIds = new HashSet<string>(StringComparer.Ordinal);
			ClanPlayerRef clanPlayerRef = (((Object)(object)Player.m_localPlayer != (Object)null) ? ClanPlayerRef.Local() : default(ClanPlayerRef));
			if (clanPlayerRef.IsValid && yieldedPlayerIds.Add(clanPlayerRef.Id))
			{
				yield return clanPlayerRef;
			}
			foreach (ZNetPeer connectedPeer in GetConnectedPeers())
			{
				ClanPlayerRef player;
				ClanPlayerRef clanPlayerRef2 = (ClanRpc.TryGetPinnedPeerIdentity(connectedPeer, out player) ? player : FromPeer(connectedPeer));
				if (clanPlayerRef2.IsValid && yieldedPlayerIds.Add(clanPlayerRef2.Id))
				{
					yield return clanPlayerRef2;
				}
			}
		}

		private static ClanPlayerRef FromCharacterId(ZDOID characterId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (characterId == ZDOID.None)
			{
				return default(ClanPlayerRef);
			}
			foreach (PlayerInfo onlinePlayer in GetOnlinePlayers())
			{
				if (onlinePlayer.m_characterID == characterId)
				{
					return FromPlayerInfo(onlinePlayer);
				}
			}
			return default(ClanPlayerRef);
		}

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

		private unsafe static string ResolvePeerPlatformId(ZNetPeer peer)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			foreach (PlayerInfo onlinePlayer in GetOnlinePlayers())
			{
				if (onlinePlayer.m_characterID == peer.m_characterID)
				{
					PlatformUserID id = onlinePlayer.m_userInfo.m_id;
					string text = ((object)(*(PlatformUserID*)(&id))/*cast due to .constrained prefix*/).ToString();
					if (!string.IsNullOrWhiteSpace(text))
					{
						return text;
					}
				}
			}
			ISocket socket = peer.m_socket;
			string text2 = ((socket != null) ? socket.GetHostName() : null) ?? "";
			if (string.IsNullOrWhiteSpace(text2) || (Object)(object)ZNet.instance == (Object)null)
			{
				return "";
			}
			return ((object)(((int)ZNet.m_onlineBackend == 0) ? new PlatformUserID(SteamPlatform, text2) : new PlatformUserID(text2))/*cast due to .constrained prefix*/).ToString();
		}

		private static IEnumerable<ZNetPeer> GetConnectedPeers()
		{
			ZNet instance = ZNet.instance;
			IEnumerable<ZNetPeer> enumerable = ((instance != null) ? instance.GetConnectedPeers() : null);
			return enumerable ?? Enumerable.Empty<ZNetPeer>();
		}

		internal static IEnumerable<PlayerInfo> GetOnlinePlayers()
		{
			ZNet instance = ZNet.instance;
			IEnumerable<PlayerInfo> enumerable = ((instance != null) ? instance.GetPlayerList() : null);
			return enumerable ?? Enumerable.Empty<PlayerInfo>();
		}
	}
	internal static class ClanRegistry
	{
		private readonly struct OperationOutcome
		{
			public readonly ClanOperationResultCode Code;

			public readonly string Status;

			public OperationOutcome(ClanOperationResultCode code, string status)
			{
				Code = code;
				Status = status;
			}
		}

		private sealed class HudCandidate
		{
			public ClanMember Member { get; }

			public ZDOID CharacterId { get; }

			public float DistanceSquared { get; }

			public HudCandidate(ClanMember member, ZDOID characterId, float distanceSquared)
			{
				//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)
				Member = member;
				CharacterId = characterId;
				DistanceSquared = distanceSquared;
			}
		}

		private sealed class HudSelectionEntry
		{
			public string PlayerId => Player.Id;

			public ClanPlayerRef Player { get; }

			public ZDOID CharacterId { get; }

			public HudSelectionEntry(ClanPlayerRef player, ZDOID characterId)
			{
				//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)
				Player = player;
				CharacterId = characterId;
			}
		}

		private readonly struct HudHealthState : IEquatable<HudHealthState>
		{
			public readonly bool HasHealth;

			public readonly float CurrentHealth;

			public readonly float MaxHealth;

			public HudHealthState(bool hasHealth, float currentHealth, float maxHealth)
			{
				HasHealth = hasHealth;
				CurrentHealth = currentHealth;
				MaxHealth = maxHealth;
			}

			public bool Equals(HudHealthState other)
			{
				if (HasHealth == other.HasHealth)
				{
					float currentHealth = CurrentHealth;
					if (currentHealth.Equals(other.CurrentHealth))
					{
						currentHealth = MaxHealth;
						return currentHealth.Equals(other.MaxHealth);
					}
				}
				return false;
			}

			public override bool Equals(object? obj)
			{
				if (obj is HudHealthState other)
				{
					return Equals(other);
				}
				return false;
			}

			public override int GetHashCode()
			{
				bool hasHealth = HasHealth;
				int num = hasHealth.GetHashCode() * 397;
				float currentHealth = CurrentHealth;
				int num2 = (num ^ currentHealth.GetHashCode()) * 397;
				currentHealth = MaxHealth;
				return num2 ^ currentHealth.GetHashCode();
			}
		}

		private sealed class PendingHudUpdate
		{
			public ClanHudSnapshot Snapshot { get; }

			public IReadOnlyDictionary<string, HudHealthState> AbsoluteHealth { get; }

			public PendingHudUpdate(ClanHudSnapshot snapshot, IReadOnlyDictionary<string, HudHealthState> absoluteHealth)
			{
				Snapshot = snapshot;
				AbsoluteHealth = absoluteHealth;
			}
		}

		private sealed class HudViewerCache
		{
			public string ClanId = "";

			public long SelectionRevision;

			public long AcknowledgedStateRevision;

			public float LastSelectionRefreshTime = float.NegativeInfinity;

			public float LastFullResendTime = float.NegativeInfinity;

			public bool SelectionRequiresFull = true;

			public readonly List<HudSelectionEntry> Selection = new List<HudSelectionEntry>();

			public readonly Dictionary<string, HudHealthState> AcknowledgedHealth = new Dictionary<string, HudHealthState>(StringComparer.Ordinal);

			public PendingHudUpdate? PendingUpdate;
		}

		private sealed class YamlRegistryDocument
		{
			[YamlMember(Alias = "format_version", ApplyNamingConventions = false, Order = 1)]
			public int FormatVersion { get; set; }

			[YamlMember(Alias = "clans", ApplyNamingConventions = false, Order = 2)]
			public List<YamlClanDto?>? Clans { get; set; }

			[YamlMember(Alias = "pending_invites", ApplyNamingConventions = false, Order = 3)]
			public List<YamlInviteDto?>? PendingInvites { get; set; }
		}

		private sealed class YamlClanDto
		{
			[YamlMember(Alias = "clan_id", ApplyNamingConventions = false, Order = 1)]
			public string? ClanId { get; set; }

			[YamlMember(Alias = "creation_order", ApplyNamingConventions = false, Order = 2)]
			public long CreationOrder { get; set; }

			[YamlMember(Alias = "name", ApplyNamingConventions = false, Order = 3)]
			public string? Name { get; set; }

			[YamlMember(Alias = "description", ApplyNamingConventions = false, Order = 4)]
			public string? Description { get; set; }

			[YamlMember(Alias = "emblem_key", ApplyNamingConventions = false, Order = 5)]
			public string? EmblemKey { get; set; }

			[YamlMember(Alias = "members", ApplyNamingConventions = false, Order = 6)]
			public List<YamlMemberDto?>? Members { get; set; }

			[YamlMember(Alias = "applications", ApplyNamingConventions = false, Order = 7)]
			public List<YamlApplicationDto?>? Applications { get; set; }
		}

		private sealed class YamlMemberDto
		{
			[YamlMember(Alias = "player", ApplyNamingConventions = false, Order = 1)]
			public YamlPlayerDto? Player { get; set; }

			[YamlMember(Alias = "role", ApplyNamingConventions = false, Order = 2)]
			public string? Role { get; set; }
		}

		private sealed class YamlApplicationDto
		{
			[YamlMember(Alias = "player", ApplyNamingConventions = false, Order = 1)]
			public YamlPlayerDto? Player { get; set; }
		}

		private sealed class YamlInviteDto
		{
			[YamlMember(Alias = "invite_id", ApplyNamingConventions = false, Order = 1)]
			public string? InviteId { get; set; }

			[YamlMember(Alias = "clan_id", ApplyNamingConventions = false, Order = 2)]
			public string? ClanId { get; set; }

			[YamlMember(Alias = "from_name", ApplyNamingConventions = false, Order = 3)]
			public string? FromName { get; set; }

			[YamlMember(Alias = "target", ApplyNamingConventions = false, Order = 4)]
			public YamlPlayerDto? Target { get; set; }
		}

		private sealed class YamlPlayerDto
		{
			[YamlMember(Alias = "platform_id", ApplyNamingConventions = false, Order = 1)]
			public string? PlatformId { get; set; }

			[YamlMember(Alias = "player_id", ApplyNamingConventions = false, Order = 2)]
			public long CharacterPlayerId { get; set; }

			[YamlMember(Alias = "name", ApplyNamingConventions = false, Order = 3)]
			public string? Name { get; set; }
		}

		private sealed class RegistryData
		{
			public readonly Dictionary<string, ClanState> ClansById = new Dictionary<string, ClanState>(StringComparer.Ordinal);

			public readonly Dictionary<string, ClanState> ClansByName = new Dictionary<string, ClanState>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<string, ClanState> PrimaryClanByPlayerId = new Dictionary<string, ClanState>(StringComparer.Ordinal);

			public readonly Dictionary<string, ClanState> GuestClanByPlayerId = new Dictionary<string, ClanState>(StringComparer.Ordinal);

			public readonly Dictionary<string, ClanInvite> PendingInvitesByTarget = new Dictionary<string, ClanInvite>(StringComparer.Ordinal);
		}

		private const int SaveFormatVersion = 6;

		private const int MaximumSaveBytes = 67108864;

		private const float PositionUpdateInterval = 1f;

		private const float ClanChatInterval = 0.25f;

		private const float ClanPingInterval = 1f;

		private const float HudSelectionRefreshInterval = 2f;

		private const float HudFullResendInterval = 30f;

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

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

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

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

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

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

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

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

		private static bool _directoryInvalidationPending;

		private static readonly UTF8Encoding StrictUtf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

		private static readonly ISerializer YamlSerializer = new SerializerBuilder().DisableAliases().WithIndentedSequences().Build();

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

		private static string? _loadedSaveFile;

		public static void Init()
		{
			_loadedSaveFile = null;
			LastPositionUpdateByPlayer.Clear();
			AnnouncedOnlinePlayerIds.Clear();
			HudCacheByViewerId.Clear();
			_directoryInvalidationPending = false;
			SwapState(new RegistryData());
		}

		public static void ResetOnlinePresence()
		{
			AnnouncedOnlinePlayerIds.Clear();
			HudCacheByViewerId.Clear();
		}

		private static bool IsRegistryWriteRequest(ClanRequestType type)
		{
			ClanDataRules.RequireEnum(type, "clan request type");
			switch (type)
			{
			case ClanRequestType.RequestSnapshot:
			case ClanRequestType.SendClanChat:
			case ClanRequestType.SendClanPing:
			case ClanRequestType.UpdatePosition:
			case ClanRequestType.RequestDirectory:
			case ClanRequestType.RequestHud:
				return false;
			default:
				return true;
			}
		}

		public static void HandleRequest(ZNetPeer? peer, ClanRequest request)
		{
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			bool retryable;
			ClanPlayerRef clanPlayerRef = ClanIdentity.FromPeer(peer, out retryable);
			if (!clanPlayerRef.IsValid)
			{
				string status = (retryable ? ClanRpc.IdentityNotReadyStatus : ClanRpc.IdentityRejectedStatus);
				ClanOperationResultCode resultCode = (retryable ? ClanOperationResultCode.IdentityUnavailable : ClanOperationResultCode.IdentityRejected);
				if (!retryable)
				{
					ClanPlugin.ClanLogger.LogWarning((object)$"Rejected clan request from peer {peer?.m_uid}: character ownership mismatch.");
				}
				SendIdentityFailure(peer, request, status, resultCode);
				return;
			}
			if (!ClanRpc.TryPinPeerIdentity(peer, clanPlayerRef))
			{
				ClanPlugin.ClanLogger.LogWarning((object)($"Rejected clan request from peer {peer?.m_uid}: character identity changed " + "during an active connection."));
				SendIdentityFailure(peer, request, ClanRpc.IdentityRejectedStatus, ClanOperationResultCode.IdentityRejected);
				return;
			}
			bool flag = true;
			ClanOperationResultCode clanOperationResultCode = ClanOperationResultCode.None;
			bool flag2 = false;
			string text;
			try
			{
				bool flag3 = IsRegistryWriteRequest(request.Type);
				flag = request.Type == ClanRequestType.RequestSnapshot || flag3;
				EnsureLoaded();
				RefreshPlayer(clanPlayerRef);
				ClanRecentPlayers.RememberPlayer(clanPlayerRef);
				flag2 = request.Type == ClanRequestType.RequestSnapshot && AnnouncedOnlinePlayerIds.Add(clanPlayerRef.Id);
				if (request.Type == ClanRequestType.RequestDirectory)
				{
					ClanRpc.SendDirectorySnapshot(peer, BuildDirectoryFor(clanPlayerRef, request.RequestId));
					return;
				}
				if (request.Type == ClanRequestType.RequestHud)
				{
					ClanHudSnapshot clanHudSnapshot = BuildHudSnapshotFor(clanPlayerRef, peer, request.ClanId, request.HudSelectionRevision, request.HudStateRevision);
					if (clanHudSnapshot != null)
					{
						ClanRpc.SendHudSnapshot(peer, clanHudSnapshot);
					}
					return;
				}
				if (flag3 && !ClanRpc.ConsumeMutationRequest(clanPlayerRef))
				{
					ClanRpc.SendSnapshot(peer, new ClanClientSnapshot
					{
						Status = ClanRpc.MutationRateLimitedStatus,
						ResponseRequestId = request.RequestId,
						ResponseResultCode = ClanOperationResultCode.RateLimited
					});
					return;
				}
				if (request.Type == ClanRequestType.RenameClan)
				{
					OperationOutcome operationOutcome = RenameClan(clanPlayerRef, request.ClanId, request.ClanName);
					text = operationOutcome.Status;
					clanOperationResultCode = operationOutcome.Code;
				}
				else
				{
					text = request.Type switch
					{
						ClanRequestType.RequestSnapshot => "", 
						ClanRequestType.CreateClan => CreateClan(clanPlayerRef, request.ClanName, request.Description, request.EmblemKey), 
						ClanRequestType.Invite => Invite(clanPlayerRef, request.ClanId, request.TargetId), 
						ClanRequestType.Apply => Apply(clanPlayerRef, request.ClanId), 
						ClanRequestType.CancelApplication => CancelApplication(clanPlayerRef), 
						ClanRequestType.AcceptInvite => AcceptInvite(clanPlayerRef, request.InviteId), 
						ClanRequestType.DeclineInvite => DeclineInvite(clanPlayerRef, request.InviteId), 
						ClanRequestType.AcceptApplication => ResolveApplication(clanPlayerRef, request.ClanId, request.TargetId, accept: true), 
						ClanRequestType.RejectApplication => ResolveApplication(clanPlayerRef, request.ClanId, request.TargetId, accept: false), 
						ClanRequestType.KickPlayer => Kick(clanPlayerRef, request.ClanId, request.TargetId), 
						ClanRequestType.TransferLeadership => TransferLeadership(clanPlayerRef, request.ClanId, request.TargetId), 
						ClanRequestType.SetRole => SetRole(clanPlayerRef, request.ClanId, request.TargetId, request.Role), 
						ClanRequestType.UpdateClanProfile => UpdateClanProfile(clanPlayerRef, request.ClanId, request.ClanName, request.Description, request.EmblemKey), 
						ClanRequestType.LeaveClan => Leave(clanPlayerRef, request.ClanId), 
						ClanRequestType.SendClanChat => SendClanChat(clanPlayerRef, request.ClanId, request.Message), 
						ClanRequestType.SendClanPing => SendClanPing(clanPlayerRef, request.ClanId, request.Position), 
						ClanRequestType.UpdatePosition => UpdatePosition(clanPlayerRef, peer, request.ClanId, request.Position), 
						_ => throw new InvalidDataException($"Unknown clan request type ({(int)request.Type})."), 
					};
				}
			}
			catch (InvalidDataException ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)$"Rejected clan request from {clanPlayerRef}: {ex.Message}");
				if (request.Type == ClanRequestType.RenameClan)
				{
					text = ClanLocalization.EncodeStatus("clan_status_rename_validation_failed");
					clanOperationResultCode = ClanOperationResultCode.Failed;
				}
				else
				{
					text = ClanLocalization.EncodeStatus("clan_status_invalid_request_server");
					clanOperationResultCode = ClanOperationResultCode.Failed;
				}
			}
			catch (Exception arg)
			{
				ClanPlugin.ClanLogger.LogWarning((object)$"Clan request from {clanPlayerRef} failed: {arg}");
				text = ClanLocalization.EncodeStatus("clan_status_request_failed");
				clanOperationResultCode = ClanOperationResultCode.Failed;
			}
			FlushDirectoryInvalidation();
			if (request.Type == ClanRequestType.RequestDirectory)
			{
				ClanRpc.SendDirectorySnapshot(peer, new ClanDirectorySnapshot
				{
					RequestId = request.RequestId,
					ResultCode = ((clanOperationResultCode == ClanOperationResultCode.None) ? ClanOperationResultCode.Failed : clanOperationResultCode),
					Status = text
				});
			}
			else
			{
				if (!flag && string.IsNullOrWhiteSpace(text))
				{
					return;
				}
				try
				{
					ClanRpc.SendSnapshot(peer, BuildSnapshotFor(clanPlayerRef, text, "", request.RequestId, clanOperationResultCode));
					if (flag2)
					{
						BroadcastPresenceSnapshots(clanPlayerRef);
					}
				}
				catch (Exception arg2)
				{
					if (flag2)
					{
						AnnouncedOnlinePlayerIds.Remove(clanPlayerRef.Id);
					}
					ClanPlugin.ClanLogger.LogWarning((object)$"Failed to build clan snapshot for {clanPlayerRef}: {arg2}");
					ClanRpc.SendSnapshot(peer, new ClanClientSnapshot
					{
						Status = ClanRpc.StateUnavailableStatus,
						ResponseRequestId = request.RequestId,
						ResponseResultCode = ClanOperationResultCode.Unavailable
					});
				}
			}
		}

		public static ClanClientSnapshot BuildSnapshotFor(ClanPlayerRef player, string status = "", string forcedOfflinePlayerId = "", long responseRequestId = 0L, ClanOperationResultCode responseResultCode = ClanOperationResultCode.None)
		{
			ClanClientSnapshot clanClientSnapshot = new ClanClientSnapshot
			{
				Status = status,
				ResponseRequestId = responseRequestId,
				ResponseResultCode = responseResultCode
			};
			if (!player.IsValid)
			{
				return clanClientSnapshot;
			}
			EnsureLoaded();
			ClanState clanState = FindPrimaryClan(player);
			if (clanState != null && clanState.Members.TryGetValue(player.Id, out ClanMember value))
			{
				clanClientSnapshot.PrimaryClanId = clanState.ClanId;
				clanClientSnapshot.PrimaryClanName = clanState.Name;
				clanClientSnapshot.PrimaryRole = value.Role;
			}
			ClanState clanState2 = FindGuestClan(player);
			if (clanState2 != null)
			{
				clanClientSnapshot.GuestClanId = clanState2.ClanId;
				clanClientSnapshot.GuestClanName = clanState2.Name;
			}
			ClanState activeClan = FindActiveClan(player);
			if (activeClan != null)
			{
				clanClientSnapshot.ClanId = activeClan.ClanId;
				clanClientSnapshot.ClanName = activeClan.Name;
				clanClientSnapshot.ClanDescription = activeClan.Description;
				clanClientSnapshot.ClanEmblemKey = activeClan.EmblemKey;
				if (activeClan.Members.TryGetValue(player.Id, out ClanMember value2))
				{
					clanClientSnapshot.SelfRole = value2.Role;
				}
				HashSet<string> onlinePlayerIds = new HashSet<string>(from online in ClanIdentity.GetOnlinePlayerRefs()
					select online.Id, StringComparer.Ordinal);
				if (forcedOfflinePlayerId.Length != 0)
				{
					onlinePlayerIds.Remove(forcedOfflinePlayerId);
				}
				clanClientSnapshot.Roster.AddRange(from member in activeClan.Members.Values.OrderByDescending((ClanMember member) => ClanDataRules.GetRolePower(member.Role)).ThenBy<ClanMember, string>((ClanMember member) => member.Player.Name, StringComparer.OrdinalIgnoreCase)
					select ToPlayerSummary(member, player, onlinePlayerIds.Contains(member.Player.Id) && FindActiveClan(member.Player) == activeClan));
				if (clanClientSnapshot.CanModerate)
				{
					clanClientSnapshot.Applications.AddRange(activeClan.Applications.Values.OrderBy<ClanPlayerRef, string>((ClanPlayerRef applicant) => applicant.Name, StringComparer.OrdinalIgnoreCase).Select(ToApplicationSummary));
				}
			}
			if (PendingInvitesByTarget.TryGetValue(player.Id, out ClanInvite value3))
			{
				if (!ClansById.TryGetValue(value3.ClanId, out ClanState value4))
				{
					throw new InvalidDataException("Invite '" + value3.InviteId + "' references missing clan '" + value3.ClanId + "'.");
				}
				clanClientSnapshot.Invite = new ClanInviteSummary
				{
					InviteId = value3.InviteId,
					ClanId = value4.ClanId,
					ClanName = value4.Name,
					FromName = value3.FromName
				};
			}
			ClanState clanState3 = ((clanState2 == null) ? FindApplicationClan(player.Id) : null);
			if (clanState3 != null && clanState3.Applications.ContainsKey(player.Id))
			{
				clanClientSnapshot.OwnApplicationClanId = clanState3.ClanId;
				clanClientSnapshot.OwnApplicationClanName = clanState3.Name;
			}
			return clanClientSnapshot;
		}

		public static ClanHudSnapshot? BuildHudSnapshotFor(ClanPlayerRef viewer, ZNetPeer? viewerPeer, string requestedClanId, long knownSelectionRevision, long knownStateRevision)
		{
			if (!viewer.IsValid)
			{
				return null;
			}
			EnsureLoaded();
			ClanState clanState = FindEffectiveClan(viewer, requestedClanId);
			if (clanState == null)
			{
				return null;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!HudCacheByViewerId.TryGetValue(viewer.Id, out HudViewerCache value))
			{
				value = new HudViewerCache();
				HudCacheByViewerId.Add(viewer.Id, value);
			}
			if (!StringComparer.Ordinal.Equals(value.ClanId, clanState.ClanId) || float.IsNegativeInfinity(value.LastSelectionRefreshTime) || realtimeSinceStartup < value.LastSelectionRefreshTime || realtimeSinceStartup - value.LastSelectionRefreshTime >= 2f)
			{
				RefreshHudSelection(value, clanState, viewer, viewerPeer, realtimeSinceStartup);
			}
			else
			{
				PruneInvalidHudSelection(value, clanState);
			}
			bool flag = value.SelectionRequiresFull;
			PendingHudUpdate pendingUpdate = value.PendingUpdate;
			if (pendingUpdate != null)
			{
				if (!StringComparer.Ordinal.Equals(pendingUpdate.Snapshot.ClanId, value.ClanId) || pendingUpdate.Snapshot.SelectionRevision != value.SelectionRevision)
				{
					value.PendingUpdate = null;
					flag = true;
				}
				else if (knownStateRevision == pendingUpdate.Snapshot.StateRevision && knownSelectionRevision == pendingUpdate.Snapshot.SelectionRevision)
				{
					CommitAcknowledgedHudUpdate(value, pendingUpdate);
					value.PendingUpdate = null;
				}
				else if (knownStateRevision == 0L)
				{
					if (pendingUpdate.Snapshot.ReplaceSelection)
					{
						return pendingUpdate.Snapshot;
					}
					value.PendingUpdate = null;
					flag = true;
				}
				else
				{
					if (knownStateRevision == value.AcknowledgedStateRevision && (pendingUpdate.Snapshot.ReplaceSelection || knownSelectionRevision == value.SelectionRevision))
					{
						return pendingUpdate.Snapshot;
					}
					value.PendingUpdate = null;
					flag = true;
				}
			}
			if (knownSelectionRevision != value.SelectionRevision || knownStateRevision != value.AcknowledgedStateRevision || knownStateRevision == 0L)
			{
				flag = true;
			}
			if (float.IsNegativeInfinity(value.LastFullResendTime) || realtimeSinceStartup < value.LastFullResendTime || realtimeSinceStartup - value.LastFullResendTime >= 30f || value.AcknowledgedStateRevision == long.MaxValue)
			{
				flag = true;
			}
			if (!flag && !HasCompleteHudHealthBaseline(value))
			{
				flag = true;
			}
			Dictionary<string, HudHealthState> dictionary = new Dictionary<string, HudHealthState>(StringComparer.Ordinal);
			ClanHudSnapshot clanHudSnapshot = new ClanHudSnapshot
			{
				ClanId = value.ClanId,
				SelectionRevision = value.SelectionRevision,
				StateRevision = NextHudRevision(value.AcknowledgedStateRevision),
				ReplaceSelection = flag
			};
			foreach (HudSelectionEntry item in value.Selection)
			{
				HudHealthState hudHealthState = ReadHudHealth(item);
				if (flag || !value.AcknowledgedHealth.TryGetValue(item.PlayerId, out var value2) || !value2.Equals(hudHealthState))
				{
					dictionary[item.PlayerId] = hudHealthState;
					clanHudSnapshot.Players.Add(new ClanHudPlayerSummary
					{
						PlayerId = item.PlayerId,
						HasHealth = hudHealthState.HasHealth,
						CurrentHealth = hudHealthState.CurrentHealth,
						MaxHealth = hudHealthState.MaxHealth
					});
				}
			}
			if (!flag && clanHudSnapshot.Players.Count == 0)
			{
				return null;
			}
			value.PendingUpdate = new PendingHudUpdate(clanHudSnapshot, dictionary);
			if (flag)
			{
				value.SelectionRequiresFull = false;
				value.LastFullResendTime = realtimeSinceStartup;
			}
			return clanHudSnapshot;
		}

		private static void RefreshHudSelection(HudViewerCache cache, ClanState clan, ClanPlayerRef viewer, ZNetPeer? viewerPeer, float now)
		{
			//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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = viewerPeer?.m_refPos ?? (((Object)(object)Player.m_localPlayer != (Object)null) ? ((Component)Player.m_localPlayer).transform.position : Vector3.zero);
			Dictionary<string, HudCandidate> dictionary = new Dictionary<string, HudCandidate>(StringComparer.Ordinal);
			Player val2 = ((viewerPeer == null) ? Player.m_localPlayer : null);
			ClanPlayerRef clanPlayerRef = (((Object)(object)val2 != (Object)null) ? ClanPlayerRef.Local() : default(ClanPlayerRef));
			bool num = viewerPeer != null || ((Object)(object)val2 != (Object)null && clanPlayerRef.IsValid && clanPlayerRef == viewer);
			ZDOID characterId = viewerPeer?.m_characterID ?? (((Object)(object)val2 != (Object)null) ? ((Character)val2).GetZDOID() : ZDOID.None);
			if (num && clan.Members.TryGetValue(viewer.Id, out ClanMember value) && FindActiveClan(value.Player) == clan)
			{
				dictionary[viewer.Id] = new HudCandidate(value, characterId, 0f);
			}
			if ((Object)(object)ZNet.instance != (Object)null)
			{
				foreach (PlayerInfo onlinePlayer in ClanIdentity.GetOnlinePlayers())
				{
					ClanPlayerRef clanPlayerRef2 = ClanIdentity.FromPlayerInfo(onlinePlayer);
					if (clanPlayerRef2.IsValid && clan.Members.TryGetValue(clanPlayerRef2.Id, out ClanMember value2) && FindActiveClan(value2.Player) == clan)
					{
						Vector3 val3 = onlinePlayer.m_position - val;
						float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
						HudCandidate hudCandidate = new HudCandidate(value2, onlinePlayer.m_characterID, sqrMagnitude);
						if (!dictionary.TryGetValue(value2.Player.Id, out var value3) || hudCandidate.DistanceSquared < value3.DistanceSquared)
						{
							dictionary[value2.Player.Id] = hudCandidate;
						}
					}
				}
			}
			List<HudSelectionEntry> selection = (from item in (from item in dictionary.Values.OrderBy((HudCandidate item) => item.DistanceSquared).ThenBy<HudCandidate, string>((HudCandidate item) => item.Member.Player.Id, StringComparer.Ordinal).Take(10)
					orderby ClanDataRules.GetRolePower(item.Member.Role) descending, item.DistanceSquared
					select item).ThenBy<HudCandidate, string>((HudCandidate item) => item.Member.Player.Name, StringComparer.OrdinalIgnoreCase).ThenBy<HudCandidate, string>((HudCandidate item) => item.Member.Player.Id, StringComparer.Ordinal)
				select new HudSelectionEntry(item.Member.Player, item.CharacterId)).ToList();
			ReplaceHudSelection(cache, clan.ClanId, selection);
			cache.LastSelectionRefreshTime = now;
		}

		private static void PruneInvalidHudSelection(HudViewerCache cache, ClanState clan)
		{
			List<HudSelectionEntry> list = null;
			for (int i = 0; i < cache.Selection.Count; i++)
			{
				HudSelectionEntry hudSelectionEntry = cache.Selection[i];
				if (clan.Members.ContainsKey(hudSelectionEntry.PlayerId) && FindActiveClan(hudSelectionEntry.Player) == clan)
				{
					list?.Add(hudSelectionEntry);
				}
				else if (list == null)
				{
					list = cache.Selection.Take(i).ToList();
				}
			}
			if (list != null)
			{
				ReplaceHudSelection(cache, clan.ClanId, list);
			}
		}

		private static void ReplaceHudSelection(HudViewerCache cache, string clanId, List<HudSelectionEntry> selection)
		{
			bool flag = !StringComparer.Ordinal.Equals(cache.ClanId, clanId) || cache.Selection.Count != selection.Count;
			if (!flag)
			{
				for (int i = 0; i < selection.Count; i++)
				{
					if (!StringComparer.Ordinal.Equals(cache.Selection[i].PlayerId, selection[i].PlayerId))
					{
						flag = true;
						break;
					}
				}
			}
			cache.ClanId = clanId;
			cache.Selection.Clear();
			cache.Selection.AddRange(selection);
			if (flag)
			{
				cache.SelectionRevision = NextHudRevision(cache.SelectionRevision);
				cache.SelectionRequiresFull = true;
				cache.PendingUpdate = null;
				cache.AcknowledgedHealth.Clear();
				cache.LastFullResendTime = float.NegativeInfinity;
			}
		}

		private static bool HasCompleteHudHealthBaseline(HudViewerCache cache)
		{
			if (cache.AcknowledgedHealth.Count != cache.Selection.Count)
			{
				return false;
			}
			return cache.Selection.All((HudSelectionEntry selected) => cache.AcknowledgedHealth.ContainsKey(selected.PlayerId));
		}

		private static HudHealthState ReadHudHealth(HudSelectionEntry selected)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			float currentHealth;
			float maxHealth;
			bool flag = TryReadHudHealth(selected.CharacterId, selected.Player, out currentHealth, out maxHealth);
			return new HudHealthState(flag, flag ? currentHealth : 0f, flag ? maxHealth : 0f);
		}

		private static void CommitAcknowledgedHudUpdate(HudViewerCache cache, PendingHudUpdate pending)
		{
			if (pending.Snapshot.ReplaceSelection)
			{
				cache.AcknowledgedHealth.Clear();
			}
			foreach (KeyValuePair<string, HudHealthState> item in pending.AbsoluteHealth)
			{
				cache.AcknowledgedHealth[item.Key] = item.Value;
			}
			cache.AcknowledgedStateRevision = pending.Snapshot.StateRevision;
		}

		private static long NextHudRevision(long revision)
		{
			if (revision < long.MaxValue)
			{
				return revision + 1;
			}
			return 1L;
		}

		private static void InvalidateHudCachesForDisconnectedPlayer(string playerId)
		{
			HudCacheByViewerId.Remove(playerId);
			foreach (HudViewerCache value in HudCacheByViewerId.Values)
			{
				if (!value.Selection.All((HudSelectionEntry selected) => !StringComparer.Ordinal.Equals(selected.PlayerId, playerId)))
				{
					List<HudSelectionEntry> selection = value.Selection.Where((HudSelectionEntry selected) => !StringComparer.Ordinal.Equals(selected.PlayerId, playerId)).ToList();
					ReplaceHudSelection(value, value.ClanId, selection);
				}
			}
		}

		private static bool TryReadHudHealth(ZDOID characterId, ClanPlayerRef expectedPlayer, out float currentHealth, out float maxHealth)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			currentHealth = 0f;
			maxHealth = 0f;
			if (((ZDOID)(ref characterId)).IsNone() || ZDOMan.instance == null)
			{
				return TryReadLocalHudHealth(expectedPlayer, out currentHealth, out maxHealth);
			}
			ZDO zDO = ZDOMan.instance.GetZDO(characterId);
			if (zDO == null || zDO.GetLong(ZDOVars.s_playerID, 0L) != expectedPlayer.CharacterPlayerId)
			{
				return TryReadLocalHudHealth(expectedPlayer, out currentHealth, out maxHealth);
			}
			maxHealth = zDO.GetFloat(ZDOVars.s_maxHealth, 0f);
			currentHealth = zDO.GetFloat(ZDOVars.s_health, maxHealth);
			return NormalizeHudHealth(ref currentHealth, ref maxHealth);
		}

		private static bool TryReadLocalHudHealth(ClanPlayerRef expectedPlayer, out float currentHealth, out float maxHealth)
		{
			currentHealth = 0f;
			maxHealth = 0f;
			if ((Object)(object)Player.m_localPlayer == (Object)null || expectedPlayer != ClanPlayerRef.Local())
			{
				return false;
			}
			currentHealth = ((Character)Player.m_localPlayer).GetHealth();
			maxHealth = ((Character)Player.m_localPlayer).GetMaxHealth();
			return NormalizeHudHealth(ref currentHealth, ref maxHealth);
		}

		private static bool NormalizeHudHealth(ref float currentHealth, ref float maxHealth)
		{
			if (float.IsNaN(currentHealth) || float.IsInfinity(currentHealth) || float.IsNaN(maxHealth) || float.IsInfinity(maxHealth) || maxHealth <= 0f || maxHealth > 1000000f)
			{
				currentHealth = 0f;
				maxHealth = 0f;
				return false;
			}
			currentHealth = Mathf.Clamp(currentHealth, 0f, maxHealth);
			return true;
		}

		private static void SendIdentityFailure(ZNetPeer? peer, ClanRequest request, string status, ClanOperationResultCode resultCode)
		{
			if (request.Type == ClanRequestType.RequestDirectory)
			{
				ClanRpc.SendDirectorySnapshot(peer, new ClanDirectorySnapshot
				{
					RequestId = request.RequestId,
					ResultCode = resultCode,
					Status = status
				});
			}
			else if (request.Type == ClanRequestType.RequestHud)
			{
				ClanRpc.SendHudSnapshot(peer, new ClanHudSnapshot());
			}
			else
			{
				ClanRpc.SendSnapshot(peer, new ClanClientSnapshot
				{
					Status = status,
					ResponseRequestId = request.RequestId,
					ResponseResultCode = resultCode
				});
			}
		}

		public static void NotifyPlayerDisconnected(ClanPlayerRef player)
		{
			if (!player.IsValid)
			{
				return;
			}
			ZNet instance = ZNet.instance;
			if (instance == null || !instance.IsServer() || ClanIdentity.GetOnlinePlayerRefs().Any((ClanPlayerRef online) => online == player))
			{
				return;
			}
			ClanRecentPlayers.MarkPlayerOffline(player);
			AnnouncedOnlinePlayerIds.Remove(player.Id);
			InvalidateHudCachesForDisconnectedPlayer(player.Id);
			try
			{
				EnsureLoaded();
				ClanState clanState = FindActiveClan(player);
				if (clanState == null)
				{
					return;
				}
				foreach (ClanMember value in clanState.Members.Values)
				{
					if (value.Player != player && FindActiveClan(value.Player) == clanState)
					{
						SendSnapshotUpdate(value.Player, "", player.Id);
					}
				}
			}
			catch (Exception ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)$"Failed to publish clan presence change for {player}: {ex.Message}");
			}
		}

		public static ClanDirectorySnapshot BuildDirectoryFor(ClanPlayerRef viewer, long requestId, string status = "")
		{
			ClanDirectorySnapshot clanDirectorySnapshot = new ClanDirectorySnapshot
			{
				RequestId = ClanDataRules.RequireRequestId(requestId),
				ResultCode = ClanOperationResultCode.Success,
				Status = status
			};
			if (!viewer.IsValid)
			{
				return clanDirectorySnapshot;
			}
			EnsureLoaded();
			ClanState viewerPrimaryClan = FindPrimaryClan(viewer);
			ClanState viewerGuestClan = FindGuestClan(viewer);
			ClanState viewerApplicationClan = ((viewerGuestClan == null) ? FindApplicationClan(viewer.Id) : null);
			PendingInvitesByTarget.TryGetValue(viewer.Id, out ClanInvite viewerInvite);
			clanDirectorySnapshot.PublicClans.AddRange(from clan in (from clan in ClansById.Values
					orderby GetDirectoryClanRank(clan, viewerInvite, viewerGuestClan, viewerPrimaryClan, viewerApplicationClan), clan.CreationOrder descending
					select clan).ThenBy<ClanState, string>((ClanState clan) => clan.Name, StringComparer.OrdinalIgnoreCase).ThenBy<ClanState, string>((ClanState clan) => clan.ClanId, StringComparer.Ordinal)
				select new ClanPublicSummary
				{
					ClanId = clan.ClanId,
					Name = clan.Name,
					Description = clan.Description,
					EmblemKey = clan.EmblemKey,
					LeaderName = GetLeader(clan).Player.Name,
					MemberCount = clan.Members.Count
				});
			ClanState viewerClan = FindActiveClan(viewer);
			ClanMember value;
			bool viewerCanModerate = viewerClan != null && viewerClan.Members.TryGetValue(viewer.Id, out value) && CanModerate(value);
			Dictionary<string, ClanState> applicationClanByPlayer = new Dictionary<string, ClanState>(StringComparer.Ordinal);
			foreach (ClanState value7 in ClansById.Values)
			{
				foreach (string key in value7.Applications.Keys)
				{
					applicationClanByPlayer[key] = value7;
				}
			}
			List<ClanRecentPlayerEntry> list = ClanRecentPlayers.GetRecentPlayers().ToList();
			if (list.All((ClanRecentPlayerEntry entry) => entry.Player != viewer))
			{
				list.Insert(0, new ClanRecentPlayerEntry(viewer, isOnline: true, DateTime.UtcNow.Ticks));
			}
			ClanState value6;
			foreach (ClanRecentPlayerEntry item in (from entry in list
				orderby entry.Player == viewer descending, viewerCanModerate && applicationClanByPlayer.TryGetValue(entry.Player.Id, out value6) && value6 == viewerClan descending, entry.IsOnline descending, entry.LastSeenUtcTicks descending
				select entry).ThenBy<ClanRecentPlayerEntry, string>((ClanRecentPlayerEntry entry) => entry.Player.Name, StringComparer.OrdinalIgnoreCase).Take(1024))
			{
				ClanPlayerRef player = item.Player;
				ClanState clanState = FindPrimaryClan(player);
				ClanState clanState2 = FindGuestClan(player);
				ClanState value2;
				ClanState clanState3 = ((clanState2 == null && applicationClanByPlayer.TryGetValue(player.Id, out value2)) ? value2 : null);
				bool flag = viewerCanModerate && clanState3 == viewerClan;
				bool flag2 = player == viewer;
				ClanInvite value3;
				ClanState value4;
				bool flag3 = PendingInvitesByTarget.TryGetValue(player.Id, out value3) && (flag2 || (viewerCanModerate && ClansById.TryGetValue(value3.ClanId, out value4) && viewerClan == value4));
				ClanDirectoryPlayerState state;
				string clanName;
				ClanState value5;
				if (clanState != null || clanState2 != null)
				{
					state = ClanDirectoryPlayerState.Clan;
					clanName = (clanState2 ?? clanState).Name;
				}
				else if ((flag2 && clanState3 != null) || flag)
				{
					state = ClanDirectoryPlayerState.Pending;
					clanName = clanState3.Name;
				}
				else if (flag3 && ClansById.TryGetValue(value3.ClanId, out value5))
				{
					state = ClanDirectoryPlayerState.Invited;
					clanName = value5.Name;
				}
				else
				{
					state = ClanDirectoryPlayerState.None;
					clanName = "";
				}
				clanDirectorySnapshot.Players.Add(new ClanDirectoryPlayerSummary
				{
					PlayerId = player.Id,
					PlayerName = player.Name,
					State = state,
					ClanName = clanName,
					IsOnline = item.IsOnline,
					IsSelf = flag2,
					CanInvite = (viewerCanModerate && !flag2 && clanState2 == null && viewerClan != null && !viewerClan.Members.ContainsKey(player.Id) && clanState3 == null && !PendingInvitesByTarget.ContainsKey(player.Id)),
					CanResolveApplication = flag,
					LastSeenUtcTicks = item.LastSeenUtcTicks
				});
			}
			return clanDirectorySnapshot;
		}

		private static int GetDirectoryClanRank(ClanState clan, ClanInvite? viewerInvite, ClanState? viewerGuestClan, ClanState? viewerPrimaryClan, ClanState? viewerApplicationClan)
		{
			if (viewerInvite != null && StringComparer.Ordinal.Equals(clan.ClanId, viewerInvite.ClanId))
			{
				return 0;
			}
			if (clan == viewerGuestClan)
			{
				return 1;
			}
			if (clan == viewerPrimaryClan)
			{
				return 2;
			}
			if (clan != viewerApplicationClan)
			{
				return 4;
			}
			return 3;
		}

		private static ClanState? FindPrimaryClan(ClanPlayerRef player)
		{
			if (!player.IsValid)
			{
				return null;
			}
			if (!PrimaryClanByPlayerId.TryGetValue(player.Id, out ClanState value))
			{
				return null;
			}
			return value;
		}

		internal static ClanWardAuthorizationResolution ResolveWardAuthorization(string platformId, long characterPlayerId, out string clanId, out string clanName)
		{
			clanId = "";
			clanName = "";
			ZNet instance = ZNet.instance;
			if (instance == null || !instance.IsServer())
			{
				return ClanWardAuthorizationResolution.Unavailable;
			}
			try
			{
				EnsureLoaded();
			}
			catch (Exception ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Could not load the Clan registry for ward authorization: " + ex.Message));
				return ClanWardAuthorizationResolution.Unavailable;
			}
			ClanPlayerRef clanPlayerRef = CreateIntegrationPlayerRef(platformId, characterPlayerId);
			if (!clanPlayerRef.IsValid)
			{
				return ClanWardAuthorizationResolution.ResolvedNoAuthorization;
			}
			if (!PrimaryClanByPlayerId.TryGetValue(clanPlayerRef.Id, out ClanState value))
			{
				return ClanWardAuthorizationResolution.ResolvedNoAuthorization;
			}
			if (!value.Members.TryGetValue(clanPlayerRef.Id, out ClanMember value2))
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Primary Clan membership index for '" + clanPlayerRef.Id + "' is inconsistent."));
				return ClanWardAuthorizationResolution.Unavailable;
			}
			if (value2.Role == ClanRole.Guest)
			{
				return ClanWardAuthorizationResolution.ResolvedNoAuthorization;
			}
			ClanRole role = value2.Role;
			if (role != ClanRole.Leader && role != ClanRole.Officer && role != ClanRole.Member)
			{
				return ClanWardAuthorizationResolution.Unavailable;
			}
			clanId = value.ClanId;
			clanName = value.Name;
			return ClanWardAuthorizationResolution.Authorized;
		}

		internal static ClanMembershipResolution ResolveMemberships(string platformId, long characterPlayerId, out string primaryClanId, out string primaryClanName, out string guestClanId, out string guestClanName)
		{
			primaryClanId = "";
			primaryClanName = "";
			guestClanId = "";
			guestClanName = "";
			ZNet instance = ZNet.instance;
			if (instance == null || !instance.IsServer())
			{
				return ClanMembershipResolution.Unavailable;
			}
			try
			{
				EnsureLoaded();
				ClanPlayerRef player = CreateIntegrationPlayerRef(platformId, characterPlayerId);
				if (!player.IsValid)
				{
					return ClanMembershipResolution.Unavailable;
				}
				if (!TryResolveIndexedMembership(player, PrimaryClanByPlayerId, expectGuest: false, out string clanId, out string clanName) || !TryResolveIndexedMembership(player, GuestClanByPlayerId, expectGuest: true, out string clanId2, out string clanName2))
				{
					ClanPlugin.ClanLogger.LogWarning((object)("Clan membership indexes for '" + player.Id + "' are inconsistent."));
					return ClanMembershipResolution.Unavailable;
				}
				primaryClanId = clanId;
				primaryClanName = clanName;
				guestClanId = clanId2;
				guestClanName = clanName2;
				return ClanMembershipResolution.Resolved;
			}
			catch (Exception ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Could not resolve authoritative Clan memberships: " + ex.Message));
				return ClanMembershipResolution.Unavailable;
			}
		}

		private static ClanPlayerRef CreateIntegrationPlayerRef(string platformId, long characterPlayerId)
		{
			string text = ClanDataRules.NormalizePlatformId(platformId);
			if (text.Length > 0 && ulong.TryParse(text, NumberStyles.None, CultureInfo.InvariantCulture, out var _))
			{
				text = "Steam_" + text;
			}
			return new ClanPlayerRef(text, characterPlayerId, "");
		}

		private static bool TryResolveIndexedMembership(ClanPlayerRef player, Dictionary<string, ClanState> membershipIndex, bool expectGuest, out string clanId, out string clanName)
		{
			clanId = "";
			clanName = "";
			if (!membershipIndex.TryGetValue(player.Id, out ClanState value))
			{
				return true;
			}
			if (value == null || !ClansById.TryGetValue(value.ClanId, out ClanState value2) || value2 != value || !value.Members.TryGetValue(player.Id, out ClanMember value3) || value3 == null || !value3.Player.IsValid || !StringComparer.Ordinal.Equals(value3.Player.Id, player.Id))
			{
				return false;
			}
			bool flag;
			if (expectGuest)
			{
				flag = value3.Role == ClanRole.Guest;
			}
			else
			{
				ClanRole role = value3.Role;
				bool flag2 = (uint)role <= 2u;
				flag = flag2;
			}
			if (!flag)
			{
				return false;
			}
			clanId = value.ClanId;
			clanName = value.Name;
			return true;
		}

		private static ClanState? FindGuestClan(ClanPlayerRef player)
		{
			if (!player.IsValid)
			{
				return null;
			}
			if (!GuestClanByPlayerId.TryGetValue(player.Id, out ClanState value))
			{
				return null;
			}
			return value;
		}

		private static ClanState? FindEffectiveClan(ClanPlayerRef player, string requestedClanId)
		{
			string y = ClanDataRules.RequireClanId(requestedClanId);
			ClanState clanState = FindActiveClan(player);
			if (clanState == null || !StringComparer.Ordinal.Equals(clanState.ClanId, y))
			{
				return null;
			}
			return clanState;
		}

		private static ClanState? FindActiveClan(ClanPlayerRef player)
		{
			if (!player.IsValid)
			{
				return null;
			}
			return FindGuestClan(player) ?? FindPrimaryClan(player);
		}

		private static string CreateClan(ClanPlayerRef actor, string requestedName, string requestedDescription, string requestedEmblemKey)
		{
			string text = ClanDataRules.RequireClanName(requestedName);
			string description = ClanDataRules.RequireClanDescription(requestedDescription);
			string text2 = ClanDataRules.RequireClanEmblemKey(requestedEmblemKey);
			if (!ClanEmoji.IsAvailableEmblemKey(text2))
			{
				return ClanLocalization.EncodeStatus("clan_status_emblem_unavailable");
			}
			if (FindPrimaryClan(actor) != null || FindGuestClan(actor) != null)
			{
				return ClanLocalization.EncodeStatus("clan_status_leave_affiliations_before_create");
			}
			if (ClansByName.ContainsKey(text))
			{
				return ClanLocalization.EncodeStatus("clan_status_name_exists", text);
			}
			if (ClansById.Count >= 1024)
			{
				return ClanLocalization.EncodeStatus("clan_status_server_clan_limit");
			}
			string text3;
			do
			{
				text3 = Guid.NewGuid().ToString("N");
			}
			while (ClansById.ContainsKey(text3));
			ClanState clanState = new ClanState(text3)
			{
				CreationOrder = GetNextClanCreationOrder(),
				Name = text,
				Description = description,
				EmblemKey = text2
			};
			clanState.Members.Add(actor.Id, new ClanMember
			{
				Player = actor,
				Role = ClanRole.Leader
			});
			ClansById.Add(clanState.ClanId, clanState);
			ClansByName.Add(clanState.Name, clanState);
			PrimaryClanByPlayerId.Add(actor.Id, clanState);
			Save(wardAuthorizationChanged: true);
			return ClanLocalization.EncodeStatus("clan_status_created", text);
		}

		private static long GetNextClanCreationOrder()
		{
			long num = 0L;
			foreach (ClanState value in ClansById.Values)
			{
				num = Math.Max(num, RequireClanCreationOrder(value.CreationOrder));
			}
			if (num == long.MaxValue)
			{
				throw new InvalidDataException("Clan creation order is exhausted.");
			}
			return num + 1;
		}

		private static long RequireClanCreationOrder(long value, string fieldName = "clan creation order")
		{
			if (value <= 0)
			{
				throw new InvalidDataException(fieldName + " must be positive.");
			}
			return value;
		}

		private static string Invite(ClanPlayerRef actor, string requestedClanId, string targetId)
		{
			ClanState clanState = RequirePermission(actor, requestedClanId, CanModerate);
			if (clanState == null)
			{
				return ClanLocalization.EncodeStatus("clan_status_only_moderators_invite");
			}
			if (!TryFindKnownPlayerById(targetId, out var player))
			{
				return ClanLocalization.EncodeStatus("clan_status_player_not_recent");
			}
			if (clanState.Members.ContainsKey(player.Id))
			{
				return ClanLocalization.EncodeStatus("clan_status_player_already_connected", player.Name, clanState.Name);
			}
			if (FindGuestClan(player) != null)
			{
				return ClanLocalization.EncodeStatus("clan_status_player_leave_guest_before_join", player.Name);
			}
			ClanInvite value = new ClanInvite
			{
				ClanId = clanState.ClanId,
				FromName = actor.Name,
				Target = player
			};
			if (!PendingInvitesByTarget.ContainsKey(player.Id) && PendingInvitesByTarget.Count >= 4096)
			{
				return ClanLocalization.EncodeStatus("clan_status_server_invite_limit");
			}
			if (PendingInvitesByTarget.TryGetValue(player.Id, out ClanInvite value2) && StringComparer.Ordinal.Equals(value2.ClanId, clanState.ClanId))
			{
				return ClanLocalization.EncodeStatus("clan_status_invite_already_pending", player.Name, clanState.Name);
			}
			PendingInvitesByTarget[player.Id] = value;
			Save();
			SendSnapshotUpdate(player, ClanLocalization.EncodeStatus("clan_status_invited_you", actor.Name, clanState.Name));
			return ClanLocalization.EncodeStatus("clan_status_invite_sent", player.Name);
		}

		private static string Apply(ClanPlayerRef actor, string requestedClanId)
		{
			string key = ClanDataRules.RequireClanId(requestedClanId);
			if (!ClansById.TryGetValue(key, out ClanState value))
			{
				return ClanLocalization.EncodeStatus("clan_status_selected_clan_missing");
			}
			if (value.Members.ContainsKey(actor.Id))
			{
				return ClanLocalization.EncodeStatus("clan_status_already_connected", value.Name);
			}
			if (FindGuestClan(actor) != null)
			{
				return ClanLocalization.EncodeStatus("clan_status_leave_guest_before_apply");
			}
			ClanState clanState = FindApplicationClan(actor.Id);
			if (clanState != value && value.Applications.Count >= 512)
			{
				return ClanLocalization.EncodeStatus("clan_status_application_limit", value.Name);
			}
			if (clanState == value)
			{
				return ClanLocalization.EncodeStatus("clan_status_application_already_pending", value.Name);
			}
			RemoveApplication(actor.Id);
			value.Applications[actor.Id] = actor;
			Save();
			if (clanState != null && clanState != value)
			{
				SendModeratorSnapshots(clanState, ClanLocalization.EncodeStatus("clan_status_application_withdrawn_notice", actor.Name));
			}
			SendModeratorSnapshots(value, ClanLocalization.EncodeStatus("clan_status_applied_notice", actor.Name));
			return ClanLocalization.EncodeStatus("clan_status_applied", value.Name);
		}

		private static string CancelApplication(ClanPlayerRef actor)
		{
			ClanState clanState = RemoveApplication(actor.Id);
			if (clanState == null)
			{
				return ClanLocalization.EncodeStatus("clan_status_no_pending_application");
			}
			Save();
			SendModeratorSnapshots(clanState, ClanLocalization.EncodeStatus("clan_status_application_withdrawn_notice", actor.Name));
			return ClanLocalization.EncodeStatus("clan_status_application_cancelled", clanState.Name);
		}

		private static string AcceptInvite(ClanPlayerRef actor, string inviteId)
		{
			if (!PendingInvitesByTarget.TryGetValue(actor.Id, out ClanInvite value) || !StringComparer.Ordinal.Equals(value.InviteId, inviteId))
			{
				return ClanLocalization.EncodeStatus("clan_status_invite_missing");
			}
			if (!ClansById.TryGetValue(value.ClanId, out ClanState value2))
			{
				PendingInvitesByTarget.Remove(actor.Id);
				Save();
				return ClanLocalization.EncodeStatus("clan_status_inviting_clan_missing");
			}
			if (value2.Members.ContainsKey(actor.Id))
			{
				return ClanLocalization.EncodeStatus("clan_status_already_connected", value2.Name);
			}
			if (FindGuestClan(actor) != null)
			{
				return ClanLocalization.EncodeStatus("clan_status_leave_guest_before_accept");
			}
			if (value2.Members.Count >= 512)
			{
				return ClanLocalization.EncodeStatus("clan_status_member_limit", value2.Name);
			}
			ClanState clanState = FindActiveClan(actor);
			AddGuestToClan(value2, actor);
			PendingInvitesByTarget.Remove(actor.Id);
			ClanState clanState2 = RemoveApplication(actor.Id);
			Save(wardAuthorizationChanged: true);
			BroadcastSnapshots(value2, ClanLocalization.EncodeStatus("clan_status_joined_guest_notice", actor.Name), actor.Id);
			if (clanState != null && clanState != value2)
			{
				BroadcastSnapshots(clanState, "", actor.Id);
			}
			if (clanState2 != null && clanState2 != value2)
			{
				SendModeratorSnapshots(clanState2, ClanLocalization.EncodeStatus("clan_status_application_withdrawn_notice", actor.Name));
			}
			return ClanLocalization.EncodeStatus("clan_status_joined_guest", value2.Name);
		}

		private static string DeclineInvite(ClanPlayerRef actor, string inviteId)
		{
			if (!PendingInvitesByTarget.TryGetValue(actor.Id, out ClanInvite value) || !StringComparer.Ordinal.Equals(value.InviteId, inviteId))
			{
				return ClanLocalization.EncodeStatus("clan_status_invite_missing");
			}
			PendingInvitesByTarget.Remove(actor.Id);
			Save();
			ClanState value2;
			string text = (ClansById.TryGetValue(value.ClanId, out value2) ? value2.Name : value.ClanId);
			return ClanLocalization.EncodeStatus("clan_status_invite_declined", text);
		}

		private static string ResolveApplication(ClanPlayerRef actor, string requestedClanId, string applicantId, bool accept)
		{
			ClanState clanState = RequirePermission(actor, requestedClanId, CanModerate);
			if (clanState == null)
			{
				return ClanLocalization.EncodeStatus("clan_status_only_moderators_resolve");
			}
			if (!clanState.Applications.TryGetValue(applicantId, out var value))
			{
				return ClanLocalization.EncodeStatus("clan_status_application_missing");
			}
			if (accept && clanState.Members.ContainsKey(value.Id))
			{
				return ClanLocalization.EncodeStatus("clan_status_player_already_connected", value.Name, clanState.Name);
			}
			if (accept && FindGuestClan(value) != null)
			{
				return ClanLocalization.EncodeStatus("clan_status_applicant_leave_guest", value.Name);
			}
			if (accept && clanState.Members.Count >= 512)
			{
				return ClanLocalization.EncodeStatus("clan_status_member_limit", clanState.Name);
			}
			if (accept)
			{
				ClanState clanState2 = FindActiveClan(value);
				AddGuestToClan(clanState, value);
				clanState.Applications.Remove(applicantId);
				PendingInvitesByTarget.Remove(applicantId);
				Save(wardAuthorizationChanged: true);
				BroadcastSnapshots(clanState, ClanLocalization.EncodeStatus("clan_status_joined_guest_notice", value.Name), actor.Id);
				if (clanState2 != null && clanState2 != clanState)
				{
					BroadcastSnapshots(clanState2, "", value.Id);
				}
				return ClanLocalization.EncodeStatus("clan_status_application_accepted_guest", value.Name);
			}
			clanState.Applications.Remove(applicantId);
			Save();
			SendSnapshotUpdate(value, ClanLocalization.EncodeStatus("clan_status_application_rejected_you", clanState.Name));
			SendModeratorSnapshots(clanState, ClanLocalization.EncodeStatus("clan_status_application_rejected_notice", value.Name), actor.Id);
			return ClanLocalization.EncodeStatus("clan_status_application_rejected", value.Name);
		}

		private static string Kick(ClanPlayerRef actor, string requestedClanId, string targetId)
		{
			ClanState clanState = RequirePermission(actor, requestedClanId, CanModerate);
			if (clanState == null)
			{
				return ClanLocalization.EncodeStatus("clan_status_remove_unauthorized");
			}
			if (!clanState.Members.TryGetValue(targetId, out ClanMember value))
			{
				return ClanLocalization.EncodeStatus("clan_status_player_not_connected");
			}
			if (value.Role == ClanRole.Leader)
			{
				return ClanLocalization.EncodeStatus("clan_status_transfer_before_remove_leader");
			}
			if (!CanAffectMember(clanState, actor, value))
			{
				return ClanLocalization.EncodeStatus("clan_status_cannot_remove_equal_role");
			}
			ClanState clanState2 = FindActiveClan(value.Player);
			clanState.Members.Remove(value.Player.Id);
			RemoveMembershipIndex(clanState, value);
			if (FindPrimaryClan(value.Player) == null && FindGuestClan(value.Player) == null)
			{
				LastPositionUpdateByPlayer.Remove(value.Player.Id);
			}
			Save(wardAuthorizationChanged: true);
			SendSnapshotUpdate(value.Player, ClanLocalization.EncodeStatus("clan_status_removed_you", clanState.Name));
			BroadcastSnapshots(clanState, ClanLocalization.EncodeStatus("clan_status_removed_notice", value.Player.Name), actor.Id);
			ClanState clanState3 = FindActiveClan(value.Player);
			if (clanState2 != clanState3 && clanState3 != null && clanState3 != clanState)
			{
				BroadcastSnapshots(clanState3, "", value.Player.Id);
			}
			return ClanLocalization.EncodeStatus("clan_status_removed", value.Player.Name);
		}

		private static string SetRole(ClanPlayerRef actor, string requestedClanId, string targetId, ClanRole requestedRole)
		{
			requestedRole = ClanDataRules.RequireAssignableRole(requestedRole, "clan role");
			ClanState clanState = FindEffectiveClan(actor, requestedClanId);
			if (clanState == null || !clanState.Members.TryGetValue(actor.Id, out ClanMember value) || !CanModerate(value))
			{
				return ClanLocalization.EncodeStatus("clan_status_only_moderators_roles");
			}
			if (!clanState.Members.TryGetValue(targetId, out ClanMember value2))
			{
				return ClanLocalization.EncodeStatus("clan_status_player_not_connected");
			}
			if (value2.Player == actor)
			{
				return ClanLocalization.EncodeStatus("clan_status_cannot_change_own_role");
			}
			if (value2.Role == ClanRole.Leader || requestedRole == ClanRole.Leader)
			{
				return ClanLocalization.EncodeStatus("clan_status_use_leadership_transfer");
			}
			if (!CanAffectMember(clanState, actor, value2))
			{
				return ClanLocalization.EncodeStatus("clan_status_cannot_change_equal_role");
			}
			if (ClanDataRules.GetRolePower(requestedRole) >= ClanDataRules.GetRolePower(value.Role))
			{
				return ClanLocalization.EncodeStatus("clan_status_cannot_assign_equal_role");
			}
			if (value2.Role == requestedRole)
			{
				return EncodeRoleStatus("clan_status_player_already_role_", requestedRole, value2.Player.Name);
			}
			bool flag = value2.Role == ClanRole.Guest;
			bool flag2 = requestedRole == ClanRole.Guest;
			if (flag && !flag2)
			{
				if (PrimaryClanByPlayerId.TryGetValue(value2.Player.Id, out ClanState value3))
				{
					if (value3 != clanState)
					{
						return ClanLocalization.EncodeStatus("clan_status_player_has_primary_clan", value2.Player.Name);
					}
					throw new InvalidDataException("Player '" + value2.Player.Id + "' is indexed as both Guest and primary in the same clan.");
				}
				if (!GuestClanByPlayerId.TryGetValue(value2.Player.Id, out ClanState value4) || value4 != clanState)
				{
					throw new InvalidDataException("Guest membership index for '" + value2.Player.Id + "' is inconsistent.");
				}
				GuestClanByPlayerId.Remove(value2.Player.Id);
				PrimaryClanByPlayerId.Add(value2.Player.Id, clanState);
			}
			else if (!flag && flag2)
			{
				if (GuestClanByPlayerId.TryGetValue(value2.Player.Id, out ClanState value5))
				{
					if (value5 != clanState)
					{
						return ClanLocalization.EncodeStatus("clan_status_player_has_guest_clan", value2.Player.Name);
					}
					throw new InvalidDataException("Player '" + value2.Player.Id + "' is indexed as both primary and Guest in the same clan.");
				}
				if (FindApplicationClan(value2.Player.Id) != null || PendingInvitesByTarget.ContainsKey(value2.Player.Id))
				{
					return ClanLocalization.EncodeStatus("clan_status_player_resolve_pending_guest", value2.Player.Name);
				}
				if (!PrimaryClanByPlayerId.TryGetValue(value2.Player.Id, out ClanState value6) || value6 != clanState)
				{
					throw new InvalidDataException("Primary membership index for '" + value2.Player.Id + "' is inconsistent.");
				}
				PrimaryClanByPlayerId.Remove(value2.Player.Id);
				GuestClanByPlayerId.Add(value2.Player.Id, clanState);
			}
			value2.Role = requestedRole;
			Save(wardAuthorizationChanged: true);
			if (FindActiveClan(value2.Player) != clanState)
			{
				SendSnapshotUpdate(value2.Player, EncodeRoleStatus("clan_status_your_role_changed_", requestedRole, clanState.Name));
			}
			BroadcastSnapshots(clanState, EncodeRoleStatus("clan_status_role_changed_notice_", requestedRole, value2.Player.Name), actor.Id);
			return EncodeRoleStatus("clan_status_role_set_", requestedRole, value2.Player.Name);
		}

		private static string TransferLeadership(ClanPlayerRef actor, string requestedClanId, string targetId)
		{
			ClanState clanState = FindEffectiveClan(actor, requestedClanId);
			if (clanState != null && !clanState.IsLeader(actor))
			{
				clanState = null;
			}
			if (clanState == null)
			{
				return ClanLocalization.EncodeStatus("clan_status_only_leader_transfer");
			}
			if (clanState.Members.TryGetValue(targetId, out ClanMember value))
			{
				ClanRole role = value.Role;
				if (role == ClanRole.Officer || role == ClanRole.Member)
				{
					if (value.Player == actor)
					{
						return ClanLocalization.EncodeStatus("clan_status_already_leader");
					}
					if (FindActiveClan(value.Player) != clanState)
					{
						return ClanLocalization.EncodeStatus("clan_status_leave_guest_before_leadership", value.Player.Name);
					}
					clanState.Members[actor.Id].Role = ClanRole.Member;
					value.Role = ClanRole.Leader;
					Save(wardAuthorizationChanged: true);
					BroadcastSnapshots(clanState, ClanLocalization.EncodeStatus("clan_status_now_leader_notice", value.Player.Name), actor.Id);
					return ClanLocalization.EncodeStatus("clan_status_leadership_transferred", value.Player.Name);
				}
			}
			return ClanLocalization.EncodeStatus("clan_status_transfer_target_role");
		}

		private static string UpdateClanProfile(ClanPlayerRef actor, string requestedClanId, string requestedName, string requestedDescription, string requestedEmblemKey)
		{
			string y = ClanDataRules.RequireClanId(requestedClanId);
			string clanName = ClanDataRules.RequireClanName(requestedName);
			string description = ClanDataRules.RequireClanDescription(requestedDescription);
			string text = ClanDataRules.RequireClanEmblemKey(requestedEmblemKey);
			if (!ClanEmoji.IsAvailableEmblemKey(text))
			{
				return ClanLocalization.EncodeStatus("clan_status_emblem_unavailable");
			}
			ClanState clanState = FindActiveClan(actor);
			if (clanState == null || !clanState.IsLeader(actor) || !StringComparer.Ordinal.Equals(clanState.ClanId, y))
			{
				return ClanLocalization.EncodeStatus("clan_status_only_leader_update_profile");
			}
			return ApplyClanProfileChange(clanState, clanName, description, text, actor.Id).Status;
		}

		private static OperationOutcome RenameClan(ClanPlayerRef actor, string requestedClanId, string requestedName)
		{
			string y = ClanDataRules.RequireClanId(requestedClanId);
			string text = ClanDataRules.RequireClanName(requestedName);
			ClanState clanState = FindActiveClan(actor);
			if (clanState == null || !StringComparer.Ordinal.Equals(clanState.ClanId, y))
			{
				return new OperationOutcome(ClanOperationResultCode.ClanChanged, ClanLocalization.EncodeStatus("clan_status_clan_changed_before_rename"));
			}
			if (!clanState.IsLeader(actor))
			{
				return new OperationOutcome(ClanOperationResultCode.Unauthorized, ClanLocalization.EncodeStatus("clan_status_only_leader_rename"));
			}
			OperationOutcome operationOutcome = ApplyClanProfileChange(clanState, text, clanState.Description, clanState.EmblemKey, actor.Id);
			return operationOutcome.Code switch
			{
				ClanOperationResultCode.Success => new OperationOutcome(ClanOperationResultCode.Success, ClanLocalization.EncodeStatus("clan_status_renamed", text)), 
				ClanOperationResultCode.Unchanged => new OperationOutcome(ClanOperationResultCode.Unchanged, ClanLocalization.EncodeStatus("clan_status_name_unchanged")), 
				_ => operationOutcome, 
			};
		}

		private static OperationOutcome ApplyClanProfileChange(ClanState clan, string clanName, string description, string emblemKey, string actorId)
		{
			if (ClansByName.TryGetValue(clanName, out ClanState value) && value != clan)
			{
				return new OperationOutcome(ClanOperationResultCode.NameTaken, ClanLocalization.EncodeStatus("clan_status_name_exists", clanName));
			}
			if (StringComparer.Ordinal.Equals(clan.Name, clanName) && StringComparer.Ordinal.Equals(clan.Description, description) && StringComparer.Ordinal.Equals(clan.EmblemKey, emblemKey))
			{
				return new OperationOutcome(ClanOperationResultCode.Unchanged, ClanLocalization.EncodeStatus("clan_status_profile_unchanged"));
			}
			NotifyProfileCommitted(CommitClanProfile(clan, clanName, description, emblemKey), actorId);
			return new OperationOutcome(ClanOperationResultCode.Success, ClanLocalization.EncodeStatus("clan_status_profile_updated"));
		}

		private static ClanState CommitClanProfile(ClanState clan, string clanName, string description, string emblemKey)
		{
			if (!ClansById.TryGetValue(clan.ClanId, out ClanState value) || value != clan || !ClansByName.TryGetValue(clan.Name, out ClanState value2) || value2 != clan)
			{
				throw new InvalidOperationException("Clan '" + clan.ClanId + "' is inconsistent with the registry indexes.");
			}
			string text = ResolveSaveFile();
			if (!string.Equals(_loadedSaveFile, text, StringComparison.Ordinal))
			{
				throw new InvalidOperationException("The clan registry storage changed while clan state was being updated.");
			}
			ValidateClanIndexes();
			YamlRegistryDocument yamlRegistryDocument = CreateSaveDocument();
			YamlClanDto? obj = yamlRegistryDocument.Clans?.SingleOrDefault((YamlClanDto candidate) => candidate != null && StringComparer.Ordinal.Equals(candidate.ClanId, clan.ClanId)) ?? throw new InvalidOperationException("Clan '" + clan.ClanId + "' is missing from the save candidate.");
			obj.Name = ClanDataRules.RequireClanName(clanName);
			obj.Description = ClanDataRules.RequireClanDescription(description);
			obj.EmblemKey = ClanDataRules.RequireClanEmblemKey(emblemKey);
			byte[] array = SerializeSave(yamlRegistryDocument);
			if (array.Length > 67108864)
			{
				throw new InvalidDataException($"Clan save exceeds the {67108864}-byte limit.");
			}
			RegistryData registryData = ParseSave(array);
			PreserveRuntimeMemberState(registryData);
			try
			{
				WriteAtomically(text, array);
			}
			catch
			{
				RecoverPersistedStateAfterSaveFailure();
				throw;
			}
			SwapState(registryData);
			_directoryInvalidationPending = true;
			ClanApi.NotifyRegistryChanged();
			return ClansById[clan.ClanId];
		}

		private static string Leave(ClanPlayerRef actor, string requestedClanId)
		{
			ClanState clanState = FindEffectiveClan(actor, requestedClanId);
			if (clanState == null || !clanState.Members.TryGetValue(actor.Id, out ClanMember value))
			{
				return ClanLocalization.EncodeStatus("clan_status_not_connected_to_selected_clan");
			}
			if (clanState.IsLeader(actor) && clanState.Members.Values.Count((ClanMember member) => member.Role != ClanRole.Guest) > 1)
			{
				return ClanLocalization.EncodeStatus("clan_status_transfer_before_leaving");
			}
			clanState.Members.Remove(actor.Id);
			RemoveMembershipIndex(clanState, value);
			if (FindPrimaryClan(actor) == null && FindGuestClan(actor) == null)
			{
				LastPositionUpdateByPlayer.Remove(actor.Id);
			}
			if (!clanState.Members.Values.Any((ClanMember member) => member.Role != ClanRole.Guest))
			{
				Dictionary<string, ClanPlayerRef> dictionary = new Dictionary<string, ClanPlayerRef>(StringComparer.Ordinal);
				HashSet<ClanState> hashSet = new HashSet<ClanState>();
				foreach (ClanMember value2 in clanState.Members.Values)
				{
					dictionary[value2.Player.Id] = value2.Player;
					ClanState clanState2 = FindPrimaryClan(value2.Player);
					if (clanState2 != null && clanState2 != clanState)
					{
						hashSet.Add(clanState2);
					}
				}
				foreach (ClanPlayerRef value3 in clanState.Applications.Values)
				{
					dictionary[value3.Id] = value3;
				}
				foreach (ClanInvite value4 in PendingInvitesByTarget.Values)
				{
					if (string.Equals(value4.ClanId, clanState.ClanId, StringComparison.Ordinal))
					{
						dictionary[value4.Target.Id] = value4.Target;
					}
				}
				RemoveClan(clanState);
				Save(wardAuthorizationChanged: true);
				foreach (ClanPlayerRef value5 in dictionary.Values)
				{
					if (value5 != actor)
					{
						SendSnapshotUpdate(value5, ClanLocalization.EncodeStatus("clan_status_disbanded_notice", clanState.Name));
					}
				}
				foreach (ClanState item in hashSet)
				{
					BroadcastSnapshots(item, "");
				}
				return ClanLocalization.EncodeStatus("clan_status_disbanded", clanState.Name);
			}
			Save(wardAuthorizationChanged: true);
			BroadcastSnapshots(clanState, ClanLocalization.EncodeStatus("clan_status_left_notice", actor.Name, clanState.Name));
			ClanState clanState3 = FindActiveClan(actor);
			if (clanState3 != null && clanState3 != clanState)
			{
				BroadcastSnapshots(clanState3, "", actor.Id);
			}
			if (value.Role != ClanRole.Guest)
			{
				return ClanLocalization.EncodeStatus("clan_status_left", clanState.Name);
			}
			return ClanLocalization.EncodeStatus("clan_status_left_guest", clanState.Name);
		}

		private static string SendClanChat(ClanPlayerRef actor, string requestedClanId, string requestedMessage)
		{
			ClanState clanState = FindEffectiveClan(actor, requestedClanId);
			if (clanState == null || !clanState.Members.TryGetValue(actor.Id, out ClanMember value))
			{
				return ClanLocalization.EncodeStatus("clan_status_not_connected_to_selected_clan");
			}
			string message = ClanDataRules.RequireText(requestedMessage, 400, "clan chat message", allowEmpty: false);
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup >= value.LastClanChatTime && realtimeSinceStartup - value.LastClanChatTime < 0.25f)
			{
				return "";
			}
			value.LastClanChatTime = realtimeSinceStartup;
			ClanRpc.BroadcastChat(clanState, actor.Name, message);
			return "";
		}

		private static string SendClanPing(ClanPlayerRef actor, string requestedClanId, Vector3 position)
		{
			//IL_0030: 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)
			ClanState clanState = FindEffectiveClan(actor, requestedClanId);
			if (clanState == null || !clanState.Members.TryGetValue(actor.Id, out ClanMember value))
			{
				return ClanLocalization.EncodeStatus("clan_status_not_connected_to_selected_clan");
			}
			ClanDataRules.RequireFiniteVector(position, "ping position");
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup >= value.LastClanPingTime && realtimeSinceStartup - value.LastClanPingTime < 1f)
			{
				return "";
			}
			value.LastClanPingTime = realtimeSinceStartup;
			ClanRpc.BroadcastPing(clanState, actor, position);
			return "";
		}

		private static string UpdatePosition(ClanPlayerRef actor, ZNetPeer? peer, string requestedClanId, Vector3 requestedPosition)
		{
			//IL_002f: 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_0035: 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)
			if (!ClanPlugin.ShareClanPositions.Value.IsOn())
			{
				return "";
			}
			ClanState clanState = FindEffectiveClan(actor, requestedClanId);
			if (clanState == null)
			{
				return "";
			}
			Vector3 val = peer?.m_refPos ?? requestedPosition;
			ClanDataRules.RequireFiniteVector(val, "player position");
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (LastPositionUpdateByPlayer.TryGetValue(actor.Id, out var value) && realtimeSinceStartup >= value && realtimeSinceStartup - value < 1f)
			{
				return "";
			}
			LastPositionUpdateByPlayer[actor.Id] = realtimeSinceStartup;
			ClanRpc.BroadcastPosition(clanState, actor, val);
			return "";
		}

		internal static bool IsEffectiveMember(ClanState clan, ClanMember member)
		{
			return FindActiveClan(member.Player) == clan;
		}

		private static ClanState? RequirePermission(ClanPlayerRef actor, string requestedClanId, Func<ClanMember, bool> canUse)
		{
			ClanState clanState = FindEffectiveClan(actor, requestedClanId);
			if (clanState == null || !clanState.Members.TryGetValue(actor.Id, out ClanMember value))
			{
				return null;
			}
			if (!canUse(value))
			{
				return null;
			}
			return clanState;
		}

		private static bool CanModerate(ClanMember member)
		{
			ClanRole role = member.Role;
			if ((uint)role <= 1u)
			{
				return true;
			}
			return false;
		}

		private static string EncodeRoleStatus(string keyPrefix, ClanRole role, params object[] arguments)
		{
			return ClanLocalization.EncodeStatus(keyPrefix + role switch
			{
				ClanRole.Leader => "leader", 
				ClanRole.Officer => "officer", 
				ClanRole.Member => "member", 
				ClanRole.Guest => "guest", 
				_ => throw new InvalidDataException("Clan role is unsupported."), 
			}, arguments);
		}

		private static bool CanAffectMember(ClanState clan, ClanPlayerRef actor, ClanMember target)
		{
			if (clan.Members.TryGetValue(actor.Id, out ClanMember value))
			{
				return ClanDataRules.GetRolePower(value.Role) > ClanDataRules.GetRolePower(target.Role);
			}
			return false;
		}

		private static void AddGuestToClan(ClanState clan, ClanPlayerRef player)
		{
			if (!player.IsValid)
			{
				throw new InvalidDataException("Cannot add an unidentified player to a clan.");
			}
			if (clan.Members.ContainsKey(player.Id))
			{
				throw new InvalidOperationException("Player is already connected to '" + clan.Name + "'.");
			}
			if (GuestClanByPlayerId.ContainsKey(player.Id))
			{
				throw new InvalidOperationException("Player must leave their current guest clan before joining another as Guest.");
			}
			if (clan.Members.Count >= 512)
			{
				throw new InvalidOperationException("Clan '" + clan.Name + "' has reached the member limit.");
			}
			ClanMember value = new ClanMember
			{
				Player = player,
				Role = ClanRole.Guest
			};
			clan.Members.Add(player.Id, value);
			GuestClanByPlayerId.Add(player.Id, clan);
		}

		private static void RemoveMembershipIndex(ClanState clan, ClanMember member)
		{
			Dictionary<string, ClanState> dictionary = ((member.Role == ClanRole.Guest) ? GuestClanByPlayerId : PrimaryClanByPlayerId);
			if (!dictionary.TryGetValue(member.Player.Id, out var value) || value != clan)
			{
				throw new InvalidDataException("Membership index for '" + member.Player.Id + "' in clan '" + clan.ClanId + "' is inconsistent.");
			}
			dictionary.Remove(member.Player.Id);
		}

		private static ClanState? RemoveApplication(string playerId)
		{
			ClanState clanState = FindApplicationClan(playerId);
			if (clanState == null)
			{
				return null;
			}
			clanState.Applications.Remove(playerId);
			return clanState;
		}

		private static ClanState? FindApplicationClan(string playerId)
		{
			return ClansById.Values.FirstOrDefault((ClanState clan) => clan.Applications.ContainsKey(playerId));
		}

		private static void RemoveClan(ClanState clan)
		{
			ClansById.Remove(clan.ClanId);
			ClansByName.Remove(clan.Name);
			foreach (ClanMember value in clan.Members.Values)
			{
				RemoveMembershipIndex(clan, value);
				if (FindPrimaryClan(value.Player) == null && FindGuestClan(value.Player) == null)
				{
					LastPositionUpdateByPlayer.Remove(value.Player.Id);
				}
			}
			string[] array = (from pair in PendingInvitesByTarget
				where StringComparer.Ordinal.Equals(pair.Value.ClanId, clan.ClanId)
				select pair.Key).ToArray();
			foreach (string key in array)
			{
				PendingInvitesByTarget.Remove(key);
			}
		}

		private static ClanMember GetLeader(ClanState clan)
		{
			return clan.Members.Values.FirstOrDefault((ClanMember member) => member.Role == ClanRole.Leader) ?? throw new InvalidDataException("Clan '" + clan.Name + "' has no leader.");
		}

		private static void BroadcastSnapshots(ClanState clan, string status, string excludedPlayerId = "")
		{
			foreach (ClanMember value in clan.Members.Values)
			{
				if (!StringComparer.Ordinal.Equals(value.Player.Id, excludedPlayerId) && FindActiveClan(value.Player) == clan)
				{
					SendSnapshotUpdate(value.Player, status);
				}
			}
		}

		private static void BroadcastPresenceSnapshots(ClanPlayerRef connectedPlayer)
		{
			ClanState clanState = FindActiveClan(connectedPlayer);
			if (clanState != null)
			{
				BroadcastSnapshots(clanState, "", connectedPlayer.Id);
			}
		}

		private static void BroadcastProfileSnapshots(ClanState clan, string excludedPlayerId)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal) { excludedPlayerId };
			foreach (ClanMember value in clan.Members.Values)
			{
				if (hashSet.Add(value.Player.Id))
				{
					SendSnapshotUpdate(value.Player, ClanLocalization.EncodeStatus("clan_status_profile_updated"));
				}
			}
			foreach (ClanPlayerRef value2 in clan.Applications.Values)
			{
				if (hashSet.Add(value2.Id))
				{
					SendSnapshotUpdate(value2, ClanLocalization.EncodeStatus("clan_status_profile_updated"));
				}
			}
			foreach (ClanInvite value3 in PendingInvitesByTarget.Values)
			{
				if (StringComparer.Ordinal.Equals(value3.ClanId, clan.ClanId) && hashSet.Add(value3.Target.Id))
				{
					SendSnapshotUpdate(value3.Target, ClanLocalization.EncodeStatus("clan_status_profile_updated"));
				}
			}
		}

		private static void NotifyProfileCommitted(ClanState clan, string excludedPlayerId)
		{
			try
			{
				BroadcastProfileSnapshots(clan, excludedPlayerId);
			}
			catch (Exception ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Clan profile '" + clan.ClanId + "' was committed, but notifying clients failed: " + ex));
			}
		}

		private static void FlushDirectoryInvalidation()
		{
			if (!_directoryInvalidationPending)
			{
				return;
			}
			_directoryInvalidationPending = false;
			try
			{
				ClanRpc.BroadcastDirectoryInvalidation();
			}
			catch (Exception arg)
			{
				ClanPlugin.ClanLogger.LogWarning((object)$"Clan data was saved, but invalidating client directories failed: {arg}");
			}
		}

		private static void SendModeratorSnapshots(ClanState clan, string status, string excludedPlayerId = "")
		{
			foreach (ClanMember value in clan.Members.Values)
			{
				if (CanModerate(value) && FindActiveClan(value.Player) == clan && !StringComparer.Ordinal.Equals(value.Player.Id, excludedPlayerId))
				{
					SendSnapshotUpdate(value.Player, status);
				}
			}
		}

		private static void SendSnapshotUpdate(ClanPlayerRef player, string status, string forcedOfflinePlayerId = "")
		{
			try
			{
				ZNetPeer val = ClanIdentity.FindPeer(player);
				bool flag = (Object)(object)Player.m_localPlayer != (Object)null && player == ClanPlayerRef.Local();
				if (val != null || flag)
				{
					ClanRpc.SendSnapshot(val, BuildSnapshotFor(player, status, forcedOfflinePlayerId, 0L));
				}
			}
			catch (Exception ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)$"Failed to update clan snapshot for {player}: {ex.Message}");
			}
		}

		private static void RefreshPlayer(ClanPlayerRef player)
		{
			if (player.IsValid)
			{
				if (PrimaryClanByPlayerId.TryGetValue(player.Id, out ClanState value) && value.Members.TryGetValue(player.Id, out ClanMember value2))
				{
					value2.Player = player;
				}
				if (GuestClanByPlayerId.TryGetValue(player.Id, out ClanState value3) && value3.Members.TryGetValue(player.Id, out ClanMember value4))
				{
					value4.Player = player;
				}
				if (PendingInvitesByTarget.TryGetValue(player.Id, out ClanInvite value5))
				{
					value5.Target = player;
				}
				ClanState clanState = (GuestClanByPlayerId.ContainsKey(player.Id) ? null : FindApplicationClan(player.Id));
				if (clanState != null && clanState.Applications.ContainsKey(player.Id))
				{
					clanState.Applications[player.Id] = player;
				}
			}
		}

		private static bool TryFindKnownPlayerById(string targetId, out ClanPlayerRef player)
		{
			string text = ClanDataRules.RequirePlayerKey(targetId, "target player key");
			foreach (ClanPlayerRef onlinePlayerRef in ClanIdentity.GetOnlinePlayerRefs())
			{
				if (StringComparer.Ordinal.Equals(onlinePlayerRef.Id, text))
				{
					player = onlinePlayerRef;
					return true;
				}
			}
			return ClanRecentPlayers.TryGetPlayer(text, out player);
		}

		private static ClanPlayerSummary ToPlayerSummary(ClanMember member, ClanPlayerRef viewer, bool isOnline)
		{
			return new ClanPlayerSummary
			{
				Player = member.Player,
				Role = member.Role,
				IsSelf = (member.Player == viewer),
				IsOnline = isOnline
			};
		}

		private static ClanApplicationSummary ToApplicationSummary(ClanPlayerRef applicant)
		{
			return new ClanApplicationSummary
			{
				PlayerId = applicant.Id,
				PlayerName = applicant.Name
			};
		}

		private static void EnsureLoaded()
		{
			string text = ResolveSaveFile();
			if (!string.Equals(_loadedSaveFile, text, StringComparison.Ordinal))
			{
				SwapState(Load(text));
				LastPositionUpdateByPlayer.Clear();
				AnnouncedOnlinePlayerIds.Clear();
				HudCacheByViewerId.Clear();
				_loadedSaveFile = text;
			}
		}

		private static string ResolveSaveFile()
		{
			return Path.Combine(ClanPlugin.DataDirectory, "clans.yml");
		}

		private static RegistryData Load(string saveFile)
		{
			string text = saveFile + ".bak";
			if (TryLoadSave(saveFile, out byte[] _, out RegistryData data, out Exception invalidContent))
			{
				ClanPlugin.ClanLogger.LogInfo((object)$"Loaded {data.ClansById.Count} clans from {saveFile}.");
				return data;
			}
			if (invalidContent == null)
			{
				if (!TryLoadSave(text, out byte[] bytes2, out RegistryData data2, out Exception invalidContent2))
				{
					if (invalidContent2 != null)
					{
						string text2 = QuarantineUnsupportedSave(text);
						ClanPlugin.ClanLogger.LogWarning((object)("Clan save was missing and its backup was unsupported or invalid. The backup was moved to " + text2 + "; the clan registry will start empty: " + invalidContent2.Message));
					}
					return new RegistryData();
				}
				WriteAtomically(saveFile, bytes2);
				ClanPlugin.ClanLogger.LogWarning((object)($"Clan save was missing. Restored {data2.ClansById.Count} clans from " + "the validated backup " + text + " to " + saveFile + "."));
				return data2;
			}
			byte[] bytes3 = null;
			RegistryData data3 = null;
			Exception invalidContent3 = null;
			if (TryLoadSave(text, out bytes3, out data3, out invalidContent3))
			{
				string text3 = QuarantineUnsupportedSave(saveFile);
				WriteAtomically(saveFile, bytes3);
				ClanPlugin.ClanLogger.LogWarning((object)("Clan save was unsupported or invalid and was moved to " + text3 + ": " + $"{invalidContent.Message} Restored {data3.ClansById.Count} clans from " + "the validated same-version backup " + text + "."));
				return data3;
			}
			string text4 = QuarantineUnsupportedSave(saveFile);
			if (invalidContent3 != null)
			{
				string text5 = QuarantineUnsupportedSave(text);
				ClanPlugin.ClanLogger.LogWarning((object)("Clan save was unsupported or invalid and was moved to " + text4 + ": " + invalidContent.Message + " Its backup was also unsupported or invalid and was moved to " + text5 + ": " + invalidContent3.Message + " The clan registry will start empty."));
			}
			else
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Clan save was unsupported or invalid and was moved to " + text4 + ": " + invalidContent.Message + " No backup was available; the clan registry will start empty."));
			}
			return new RegistryData();
		}

		private static bool TryLoadSave(string saveFile, out byte[]? bytes, out RegistryData? data, out Exception? invalidContent)
		{
			bytes = null;
			data = null;
			invalidContent = null;
			try
			{
				bytes = ReadSaveBytes(saveFile);
				data = ParseSave(bytes);
				return true;
			}
			catch (FileNotFoundException)
			{
				return false;
			}
			catch (DirectoryNotFoundException)
			{
				return false;
			}
			catch (Exception ex3) when (IsInvalidSaveContent(ex3))
			{
				invalidContent = ex3;
				return false;
			}
		}

		private static bool IsInvalidSaveContent(Exception error)
		{
			if (error is InvalidDataException || error is DecoderFallbackException || error is YamlException)
			{
				return true;
			}
			return false;
		}

		private static RegistryData ParseSave(byte[] bytes)
		{
			string input = DecodeStrictUtf8(bytes);
			YamlRegistryDocument yamlRegistryDocument = YamlDeserializer.Deserialize<YamlRegistryDocument>(input);
			if (yamlRegistryDocument == null)
			{
				throw new InvalidDataException("Clan save is empty.");
			}
			if (yamlRegistryDocument.FormatVersion != 6)
			{
				throw new InvalidDataException($"Save format version {yamlRegistryDocument.FormatVersion} is unsupported; " + $"only version {6} is accepted.");
			}
			if (yamlRegistryDocument.Clans == null)
			{
				throw new InvalidDataException("Clan save is missing the clans sequence.");
			}
			if (yamlRegistryDocument.PendingInvites == null)
			{
				throw new InvalidDataException("Clan save is missing the pending_invites sequence.");
			}
			RegistryData registryData = new RegistryData();
			HashSet<long> hashSet = new HashSet<long>();
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			Dictionary<string, ClanState> dictionary = new Dictionary<string, ClanState>(StringComparer.Ordinal);
			ClanDataRules.RequireCount(yamlRegistryDocument.Clans.Count, 1024, "clan");
			foreach (YamlClanDto clan in yamlRegistryDocument.Clans)
			{
				ClanState clanState = ReadClan(clan);
				if (!hashSet.Add(clanState.CreationOrder))
				{
					throw new InvalidDataException($"Duplicate clan creation order '{clanState.CreationOrder}'.");
				}
				if (registryData.ClansById.ContainsKey(clanState.ClanId))
				{
					throw new InvalidDataException("Duplicate clan id '" + clanState.ClanId + "'.");
				}
				if (registryData.ClansByName.ContainsKey(clanState.Name))
				{
					throw new InvalidDataException("Duplicate clan name '" + clanState.Name + "'.");
				}
				registryData.ClansById.Add(clanState.ClanId, clanState);
				registryData.ClansByName.Add(clanState.Name, clanState);
				foreach (KeyValuePair<string, ClanMember> member in clanState.Members)
				{
					Dictionary<string, ClanState> dictionary2 = ((member.Value.Role == ClanRole.Guest) ? registryData.GuestClanByPlayerId : registryData.PrimaryClanByPlayerId);
					if (dictionary2.ContainsKey(member.Key))
					{
						string text = ((member.Value.Role == ClanRole.Guest) ? "Guest" : "primary");
						throw new InvalidDataException("Player '" + member.Key + "' belongs to more than one " + text + " clan.");
					}
					dictionary2.Add(member.Key, clanState);
				}
				foreach (string key in clanState.Applications.Keys)
				{
					if (!hashSet2.Add(key))
					{
						throw new InvalidDataException("Player '" + key + "' has more than one application.");
					}
					dictionary.Add(key, clanState);
				}
			}
			foreach (string item in hashSet2)
			{
				ClanState clanState2 = dictionary[item];
				if (registryData.GuestClanByPlayerId.ContainsKey(item))
				{
					throw new InvalidDataException("Player '" + item + "' cannot have a Guest clan and a pending application.");
				}
				if (clanState2.Members.ContainsKey(item))
				{
					throw new InvalidDataException("Player '" + item + "' cannot apply to a clan they already belong to.");
				}
			}
			ClanDataRules.RequireCount(yamlRegistryDocument.PendingInvites.Count, 4096, "invite");
			HashSet<string> hashSet3 = new HashSet<string>(StringComparer.Ordinal);
			foreach (YamlInviteDto pendingInvite in yamlRegistryDocument.PendingInvites)
			{
				ClanInvite clanInvite = ReadInvite(pendingInvite);
				if (!hashSet3.Add(clanInvite.InviteId))
				{
					throw new InvalidDataException("Duplicate invite id '" + clanInvite.InviteId + "'.");
				}
				if (!registryData.ClansById.TryGetValue(clanInvite.ClanId, out ClanState value))
				{
					throw new InvalidDataException("Invite references missing clan '" + clanInvite.ClanId + "'.");
				}
				if (registryData.GuestClanByPlayerId.ContainsKey(clanInvite.Target.Id))
				{
					throw new InvalidDataException("Invite target '" + clanInvite.Target.Id + "' already has a Guest clan.");
				}
				if (value.Members.ContainsKey(clanInvite.Target.Id))
				{
					throw new InvalidDataException("Invite target '" + clanInvite.Target.Id + "' already belongs to the inviting clan.");
				}
				if (registryData.PendingInvitesByTarget.ContainsKey(clanInvite.Target.Id))
				{
					throw new InvalidDataException("Player '" + clanInvite.Target.Id + "' has more than one pending invite.");
				}
				registryData.PendingInvitesByTarget.Add(clanInvite.Target.Id, clanInvite);
			}
			return registryData;
		}

		private static string DecodeStrictUtf8(byte[] bytes)
		{
			int num = ((bytes.Length >= 3 && bytes[0] == 239 && bytes[1] == 187 && bytes[2] == 191) ? 3 : 0);
			return StrictUtf8.GetString(bytes, num, bytes.Length - num);
		}

		private static ClanState ReadClan(YamlClanDto? source)
		{
			if (source == null)
			{
				throw new InvalidDataException("Clan save contains a null clan entry.");
			}
			ClanState clanState = new ClanState(ClanDataRules.RequireClanId(source.ClanId))
			{
				CreationOrder = RequireClanCreationOrder(source.CreationOrder),
				Name = ClanDataRules.RequireClanName(source.Name),
				Description = ClanDataRules.RequireClanDescription(source.Description),
				EmblemKey = ClanDataRules.RequireClanEmblemKey(source.EmblemKey)
			};
			if (source.Members == null)
			{
				throw new InvalidDataException("Clan '" + clanState.Name + "' is missing the members sequence.");
			}
			ClanDataRules.RequireCount(source.Members.Count, 512, "clan member");
			if (source.Members.Count == 0)
			{
				throw new InvalidDataException("Clan '" + clanState.Name + "' has no members.");
			}
			int num = 0;
			foreach (YamlMemberDto member in source.Members)
			{
				YamlMemberDto obj = member ?? throw new InvalidDataException("Clan '" + clanState.Name + "' contains a null member entry.");
				ClanPlayerRef player = ReadPlayer(obj.Player, "clan member");
				ClanRole clanRole = ParseRole(obj.Role, "clan role");
				if (clanRole == ClanRole.Leader)
				{
					num++;
				}
				if (clanState.Members.ContainsKey(player.Id))
				{
					throw new InvalidDataException("Duplicate member '" + player.Id + "' in clan '" + clanState.Name + "'.");
				}
				clanState.Members.Add(player.Id, new ClanMember
				{
					Player = player,
					Role = clanRole
				});
			}
			if (num != 1)
			{
				throw new InvalidDataException($"Clan '{clanState.Name}' must have exactly one leader; found {num}.");
			}
			if (source.Applications == null)
			{
				throw new InvalidDataException("Clan '" + clanState.Name + "' is missing the applications sequence.");
			}
			ClanDataRules.RequireCount(source.Applications.Count, 512, "application");
			foreach (YamlApplicationDto application in source.Applications)
			{
				ClanPlayerRef value = ReadPlayer((application ?? throw new InvalidDataException("Clan '" + clanState.Name + "' contains a null application entry.")).Player, "application player");
				if (clanState.Applications.ContainsKey(value.Id))
				{
					throw new InvalidDataException("Duplicate application from '" + value.Id + "' in clan '" + clanState.Name + "'.");
				}
				clanState.Applications.Add(value.Id, value);
			}
			return clanState;
		}

		private static ClanInvite ReadInvite(YamlInviteDto? source)
		{
			if (source == null)
			{
				throw new InvalidDataException("Clan save contains a null invite entry.");
			}
			return new ClanInvite
			{
				InviteId = ClanDataRules.RequireText(source.InviteId, 64, "invite id", allowEmpty: false),
				ClanId = ClanDataRules.RequireClanId(source.ClanId, "invite clan id"),
				FromName = ClanDataRules.RequireText(source.FromName, 64, "invite sender name"),
				Target = ReadPlayer(source.Target, "invite target")
			};
		}

		private static ClanPlayerRef ReadPlayer(YamlPlayerDto? source, string fieldName)
		{
			if (source == null)
			{
				throw new InvalidDataException(fieldName + " is missing.");
			}
			string platformId = ClanDataRules.RequirePlatformId(source.PlatformId, fieldName + " platform id");
			long playerId = ClanDataRules.RequireCharacterPlayerId(source.CharacterPlayerId, fieldName + " character player id");
			string name = ClanDataRules.RequireText(source.Name, 64, fieldName + " name");
			ClanPlayerRef result = new ClanPlayerRef(platformId, playerId, name);
			if (!result.IsValid)
			{
				throw new InvalidDataException(fieldName + " identity is invalid.");
			}
			return result;
		}

		private static ClanRole ParseRole(string? value, string fieldName)
		{
			string text = ClanDataRules.RequireText(value, 16, fieldName, allowEmpty: false);
			return text switch
			{
				"leader" => ClanRole.Leader, 
				"officer" => ClanRole.Officer, 
				"member" => ClanRole.Member, 
				"guest" => ClanRole.Guest, 
				_ => throw new InvalidDataException(fieldName + " has unknown value '" + text + "'."), 
			};
		}

		private static void Save(bool wardAuthorizationChanged = false)
		{
			try
			{
				string text = ResolveSaveFile();
				if (!string.Equals(_loadedSaveFile, text, StringComparison.Ordinal))
				{
					throw new InvalidOperationException("The clan registry storage changed while clan state was being updated.");
				}
				ValidateClanIndexes();
				ClanDataRules.RequireCount(ClansById.Count, 1024, "clan");
				ClanDataRules.RequireCount(PendingInvitesByTarget.Count, 4096, "invite");
				byte[] array = SerializeSave(CreateSaveDocument());
				if (array.Length > 67108864)
				{
					throw new InvalidDataException($"Clan save exceeds the {67108864}-byte limit.");
				}
				ParseSave(array);
				WriteAtomically(text, array);
				_directoryInvalidationPending = true;
			}
			catch
			{
				RecoverPersistedStateAfterSaveFailure();
				throw;
			}
			if (wardAuthorizationChanged)
			{
				ClanApi.NotifyRegistryChanged();
			}
		}

		private static void RecoverPersistedStateAfterSaveFailure()
		{
			if (!RestorePersistedState())
			{
				_loadedSaveFile = null;
				LastPositionUpdateByPlayer.Clear();
				SwapState(new RegistryData());
				ClanPlugin.ClanLogger.LogError((object)"Clan registry was invalidated after both saving and restoring the persisted state failed. The next registry access must reload clans.yml.");
			}
		}

		private static void PreserveRuntimeMemberState(RegistryData candidate)
		{
			foreach (KeyValuePair<string, ClanState> item in ClansById)
			{
				if (!candidate.ClansById.TryGetValue(item.Key, out ClanState value))
				{
					continue;
				}
				foreach (KeyValuePair<string, ClanMember> member in item.Value.Members)
				{
					if (value.Members.TryGetValue(member.Key, out ClanMember value2))
					{
						value2.LastClanChatTime = member.Value.LastClanChatTime;
						value2.LastClanPingTime = member.Value.LastClanPingTime;
					}
				}
			}
		}

		private static void ValidateClanIndexes()
		{
			if (ClansById.Count != ClansByName.Count)
			{
				throw new InvalidDataException("Clan id and name indexes contain different counts.");
			}
			foreach (KeyValuePair<string, ClanState> item in ClansByName)
			{
				string y = ClanDataRules.RequireClanName(item.Key);
				if (!StringComparer.Ordinal.Equals(item.Key, y) || !StringComparer.Ordinal.Equals(item.Value.Name, item.Key) || !ClansById.TryGetValue(item.Value.ClanId, out ClanState value) || value != item.Value)
				{
					throw new InvalidDataException("Clan name index '" + item.Key + "' is not canonical or points to the wrong clan.");
				}
			}
			int num = 0;
			int num2 = 0;
			HashSet<long> hashSet = new HashSet<long>();
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet3 = new HashSet<string>(StringComparer.Ordinal);
			foreach (KeyValuePair<string, ClanState> item2 in ClansById)
			{
				ClanState value2 = item2.Value;
				long num3 = RequireClanCreationOrder(value2.CreationOrder);
				if (!hashSet.Add(num3))
				{
					throw new InvalidDataException($"Clan '{item2.Key}' has duplicate creation order '{num3}'.");
				}
				if (!StringComparer.Ordinal.Equals(item2.Key, value2.ClanId) || !ClansByName.TryGetValue(value2.Name, out ClanState value3) || value3 != value2)
				{
					throw new InvalidDataException("Clan '" + item2.Key + "' is inconsistent with the registry indexes.");
				}
				foreach (KeyValuePair<string, ClanMember> member in value2.Members)
				{
					ClanMember value4 = member.Value;
					if (value4 == null || !value4.Player.IsValid || !StringComparer.Ordinal.Equals(member.Key, value4.Player.Id))
					{
						throw new InvalidDataException("Clan '" + item2.Key + "' has an inconsistent member index for '" + member.Key + "'.");
					}
					if (ClanDataRules.RequireEnum(value4.Role, "clan role") == ClanRole.Guest)
					{
						if (!hashSet3.Add(member.Key) || !GuestClanByPlayerId.TryGetValue(member.Key, out ClanState value5) || value5 != value2)
						{
							throw new InvalidDataException("Clan '" + item2.Key + "' has an inconsistent Guest index for '" + member.Key + "'.");
						}
						num2++;
					}
					else
					{
						if (!hashSet2.Add(member.Key) || !PrimaryClanByPlayerId.TryGetValue(member.Key, out ClanState value6) || value6 != value2)
						{
							throw new InvalidDataException("Clan '" + item2.Key + "' has an inconsistent primary index for '" + member.Key + "'.");
						}
						num++;
					}
				}
			}
			if (PrimaryClanByPlayerId.Count != num || GuestClanByPlayerId.Count != num2)
			{
				throw new InvalidDataException("The role-aware player-to-clan indexes contain a different number of members than the clans.");
			}
		}

		private static bool RestorePersistedState()
		{
			string loadedSaveFile = _loadedSaveFile;
			if (loadedSaveFile == null || string.IsNullOrWhiteSpace(loadedSaveFile))
			{
				return false;
			}
			try
			{
				SwapState(Load(loadedSaveFile));
				LastPositionUpdateByPlayer.Clear();
				return true;
			}
			catch (Exception arg)
			{
				ClanPlugin.ClanLogger.LogError((object)$"Failed to restore clan state after a save error: {arg}");
				return false;
			}
		}

		private static YamlRegistryDocument CreateSaveDocument()
		{
			List<YamlClanDto> list = new List<YamlClanDto>();
			List<YamlInviteDto> list2 = new List<YamlInviteDto>();
			YamlRegistryDocument result = new YamlRegistryDocument
			{
				FormatVersion = 6,
				Clans = list,
				PendingInvites = list2
			};
			foreach (ClanState item in ClansById.Values.OrderBy<ClanState, string>((ClanState clan) => clan.ClanId, StringComparer.Ordinal))
			{
				list.Add(CreateClanDto(item));
			}
			foreach (KeyValuePair<string, ClanInvite> item2 in PendingInvitesByTarget.OrderBy<KeyValuePair<string, ClanInvite>, string>((KeyValuePair<string, ClanInvite> pair) => pair.Key, StringComparer.Ordinal))
			{
				ClanInvite value = item2.Value;
				if (value == null || !value.Target.IsValid || !StringComparer.Ordinal.Equals(item2.Key, value.Target.Id))
				{
					throw new InvalidDataException("Pending invite target index '" + item2.Key + "' is inconsistent.");
				}
				list2.Add(CreateInviteDto(value));
			}
			return result;
		}

		private static byte[] SerializeSave(YamlRegistryDocument document)
		{
			string text = YamlSerializer.Serialize(document).Replace("\r\n", "\n").Replace('\r', '\n');
			if (!text.EndsWith("\n", StringComparison.Ordinal))
			{
				text += "\n";
			}
			return StrictUtf8.GetBytes(text);
		}

		private static YamlClanDto CreateClanDto(ClanState clan)
		{
			ClanDataRules.RequireCount(clan.Members.Count, 512, "clan member");
			ClanDataRules.RequireCount(clan.Applications.Count, 512, "application");
			if (clan.Members.Count == 0)
			{
				throw new InvalidDataException("Clan '" + clan.Name + "' has no members.");
			}
			List<YamlMemberDto> list = new List<YamlMemberDto>();
			List<YamlApplicationDto> list2 = new List<YamlApplicationDto>();
			YamlClanDto result = new YamlClanDto
			{
				ClanId = ClanDataRules.RequireClanId(clan.ClanId),
				CreationOrder = RequireClanCreationOrder(clan.CreationOrder),
				Name = ClanDataRules.RequireClanName(clan.Name),
				Description = ClanDataRules.RequireClanDescription(clan.Description),
				EmblemKey = ClanDataRules.RequireClanEmblemKey(clan.EmblemKey),
				Members = list,
				Applications = list2
			};
			int num = 0;
			foreach (KeyValuePair<string, ClanMember> item in clan.Members.OrderBy<KeyValuePair<string, ClanMember>, string>((KeyValuePair<string, ClanMember> pair) => pair.Key, StringComparer.Ordinal))
			{
				ClanMember value = item.Value;
				if (value == null || !value.Player.IsValid || !StringComparer.Ordinal.Equals(item.Key, value.Player.Id))
				{
					throw new InvalidDataException("Clan '" + clan.Name + "' contains an inconsistent member '" + item.Key + "'.");
				}
				ClanRole clanRole = ClanDataRules.RequireEnum(value.Role, "clan role");
				if (clanRole == ClanRole.Leader)
				{
					num++;
				}
				list.Add(new YamlMemberDto
				{
					Player = CreatePlayerDto(value.Player, "clan member"),
					Role = FormatRole(clanRole)
				});
			}
			if (num != 1)
			{
				throw new InvalidDataException("Clan '" + clan.Name + "' must have exactly one leader.");
			}
			foreach (KeyValuePair<string, ClanPlayerRef> item2 in clan.Applications.OrderBy<KeyValuePair<string, ClanPlayerRef>, string>((KeyValuePair<string, ClanPlayerRef> pair) => pair.Key, StringComparer.Ordinal))
			{
				ClanPlayerRef value2 = item2.Value;
				if (!value2.IsValid || !StringComparer.Ordinal.Equals(item2.Key, value2.Id))
				{
					throw new InvalidDataException("Clan '" + clan.Name + "' contains an inconsistent application '" + item2.Key + "'.");
				}
				list2.Add(new YamlApplicationDto
				{
					Player = CreatePlayerDto(value2, "application player")
				});
			}
			return result;
		}

		private static YamlInviteDto CreateInviteDto(ClanInvite invite)
		{
			return new YamlInviteDto
			{
				InviteId = ClanDataRules.RequireText(invite.InviteId, 64, "invite id", allowEmpty: false),
				ClanId = ClanDataRules.RequireClanId(invite.ClanId, "invite clan id"),
				FromName = ClanDataRules.RequireText(invite.FromName, 64, "invite sender name"),
				Target = CreatePlayerDto(invite.Target, "invite target")
			};
		}

		private static YamlPlayerDto CreatePlayerDto(ClanPlayerRef player, string fieldName)
		{
			if (!player.IsValid)
			{
				throw new InvalidDataException(fieldName + " identity is invalid.");
			}
			return new YamlPlayerDto
			{
				PlatformId = ClanDataRules.RequirePlatformId(player.PlatformId, fieldName + " platform id"),
				CharacterPlayerId = ClanDataRules.RequireCharacterPlayerId(player.CharacterPlayerId, fieldName + " character player id"),
				Name = ClanDataRules.RequireText(player.Name, 64, fieldName + " name")
			};
		}

		private static string FormatRole(ClanRole role)
		{
			return ClanDataRules.RequireEnum(role, "clan role") switch
			{
				ClanRole.Leader => "leader", 
				ClanRole.Officer => "officer", 
				ClanRole.Member => "member", 
				ClanRole.Guest => "guest", 
				_ => throw new InvalidDataException("Clan role is unsupported."), 
			};
		}

		private static void WriteAtomically(string saveFile, byte[] bytes)
		{
			string? directoryName = Path.GetDirectoryName(saveFile);
			if (string.IsNullOrWhiteSpace(directoryName))
			{
				throw new InvalidOperationException("Clan save directory is invalid.");
			}
			Directory.CreateDirectory(directoryName);
			string text = saveFile + ".tmp-" + Guid.NewGuid().ToString("N");
			try
			{
				using (FileStream fileStream = new FileStream(text, FileMode.CreateNew, FileAccess.Write, FileShare.None))
				{
					fileStream.Write(bytes, 0, bytes.Length);
					fileStream.Flush(flushToDisk: true);
				}
				if (File.Exists(saveFile))
				{
					string destinationBackupFileName = saveFile + ".bak";
					File.Replace(text, saveFile, destinationBackupFileName, ignoreMetadataErrors: true);
				}
				else
				{
					File.Move(text, saveFile);
				}
			}
			catch
			{
				try
				{
					if (File.Exists(text))
					{
						File.Delete(text);
					}
				}
				catch (Exception ex)
				{
					ClanPlugin.ClanLogger.LogWarning((object)("Failed to clean temporary clan save '" + text + "': " + ex.Message));
				}
				throw;
			}
		}

		private static byte[] ReadSaveBytes(string saveFile)
		{
			FileInfo fileInfo = new FileInfo(saveFile);
			if (fileInfo.Length < 0 || fileInfo.Length > 67108864)
			{
				throw new InvalidDataException($"Clan save exceeds the {67108864}-byte limit.");
			}
			byte[] array = File.ReadAllBytes(saveFile);
			if (array.Length > 67108864)
			{
				throw new InvalidDataException($"Clan save exceeds the {67108864}-byte limit.");
			}
			return array;
		}

		private static string QuarantineUnsupportedSave(string saveFile)
		{
			string text = DateTime.UtcNow.ToString("yyyyMMddHHmmss", CultureInfo.InvariantCulture);
			for (int i = 0; i < 10; i++)
			{
				string text2 = saveFile + ".unsupported-or-corrupt-" + text + "-" + Guid.NewGuid().ToString("N");
				if (!File.Exists(text2))
				{
					try
					{
						File.Move(saveFile, text2);
						return text2;
					}
					catch (IOException) when (File.Exists(saveFile) && File.Exists(text2))
					{
					}
				}
			}
			throw new IOException("Could not allocate a unique quarantine file for '" + saveFile + "'.");
		}

		private static void SwapState(RegistryData data)
		{
			ClansById = data.ClansById;
			ClansByName = data.ClansByName;
			PrimaryClanByPlayerId = data.PrimaryClanByPlayerId;
			GuestClanByPlayerId = data.GuestClanByPlayerId;
			PendingInvitesByTarget = data.PendingInvitesByTarget;
		}
	}
	internal static class ClanRpc
	{
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClanRpc
		{
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				ClanEmoji.RegisterEmojiFileRpc(__instance, peer);
				if (__instance.IsServer())
				{
					peer.m_rpc.Register<ZPackage>(RequestRpc, (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage package)
					{
						ServerHandleRequest(peer, rpc, package);
					});
				}
				else
				{
					peer.m_rpc.Register<ZPackage>(ResponseRpc, (Action<ZRpc, ZPackage>)ClientHandleResponse);
				}
			}
		}

		[HarmonyPatch(typeof(Game), "Start")]
		private static class ResetClanSessionOnGameStart
		{
			private static void Postfix()
			{
				ResetSession();
			}
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private static class ClearClanSession
		{
			private static void Prefix()
			{
				ResetSession();
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect", new Type[] { typeof(ZNetPeer) })]
		private static class ClearEmojiPeerOnDisconnect
		{
			private static void Prefix(ZNetPeer peer, out ClanPlayerRef __state)
			{
				if (peer?.m_rpc != null && PeerIdentities.TryGetValue(peer.m_rpc, out var value))
				{
					__state = value;
				}
				else
				{
					ZNet instance = ZNet.instance;
					__state = ((instance != null && instance.IsServer()) ? ClanIdentity.FromPeer(peer) : default(ClanPlayerRef));
				}
				ClanEmoji.ForgetEmojiPeer(peer?.m_rpc);
				if (peer?.m_rpc != null)
				{
					DirectoryRequestBudgets.Remove(peer.m_rpc);
					SnapshotRequestBudgets.Remove(peer.m_rpc);
					HudRequestBudgets.Remove(peer.m_rpc);
					PeerIdentities.Remove(peer.m_rpc);
				}
			}

			private static void Postfix(ClanPlayerRef __state)
			{
				ClanRegistry.NotifyPlayerDisconnected(__state);
			}
		}

		private sealed class RequestBudget
		{
			public float WindowStartedAt;

			public int Requests;

			public RequestBudget(float windowStartedAt)
			{
				WindowStartedAt = windowStartedAt;
			}
		}

		internal static readonly string IdentityNotReadyStatus = ClanLocalization.EncodeStatus("clan_status_identity_not_ready");

		internal static readonly string IdentityRejectedStatus = ClanLocalization.EncodeStatus("clan_status_identity_rejected");

		internal static readonly string SnapshotRateLimitedStatus = ClanLocalization.EncodeStatus("clan_status_snapshot_rate_limited");

		internal static readonly string MutationRateLimitedStatus = ClanLocalization.EncodeStatus("clan_status_mutation_rate_limited");

		internal static readonly string DirectoryRateLimitedStatus = ClanLocalization.EncodeStatus("clan_status_directory_rate_limited");

		internal static readonly string StateUnavailableStatus = ClanLocalization.EncodeStatus("clan_status_state_unavailable");

		private const int MaximumRequestBytes = 16384;

		private const int MaximumDirectoryResponseBytes = 524288;

		private const int MaximumDirectoryRequestsPerWindow = 1;

		private const float DirectoryRequestWindowSeconds = 2f;

		private const int MaximumSnapshotRequestsPerWindow = 5;

		private const float SnapshotRequestWindowSeconds = 2f;

		private const int MaximumHudRequestsPerWindow = 5;

		private const float HudRequestWindowSeconds = 2f;

		private const int MaximumMutationRequestsPerWindow = 6;

		private const float MutationRequestWindowSeconds = 5f;

		private const int MutationBudgetPruneThreshold = 256;

		private const int InitialSnapshotRetryCount = 20;

		private const float InitialSnapshotRetryIntervalSeconds = 0.5f;

		private const string ProtocolVersion = "v13";

		private static readonly string DirectoryTruncatedStatus = ClanLocalization.EncodeStatus("clan_status_directory_truncated");

		private static readonly string RequestRpc = "sighsorry.Clan.rpc.request.v13";

		private static readonly string ResponseRpc = "sighsorry.Clan.rpc.response.v13";

		private static readonly Dictionary<ZRpc, RequestBudget> DirectoryRequestBudgets = new Dictionary<ZRpc, RequestBudget>();

		private static readonly Dictionary<ZRpc, RequestBudget> SnapshotRequestBudgets = new Dictionary<ZRpc, RequestBudget>();

		private static readonly Dictionary<ZRpc, RequestBudget> HudRequestBudgets = new Dictionary<ZRpc, RequestBudget>();

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

		private static readonly Dictionary<ZRpc, ClanPlayerRef> PeerIdentities = new Dictionary<ZRpc, ClanPlayerRef>();

		private static readonly object RequestIdLock = new object();

		private static long _nextRequestId;

		private static long _pendingDirectoryRequestId;

		private static int _initialSnapshotRetriesRemaining;

		private static float _nextInitialSnapshotRetryAt;

		private static bool _initialSnapshotBootstrapStarted;

		private static bool _initialSnapshotBootstrapComplete;

		private static bool _identityReady;

		private static bool _retryDirectoryWhenIdentityReady;

		private static float _directoryIdentityRetryAt;

		private static bool _hudRecoveryRequestInProgress;

		public static ClanClientSnapshot CurrentSnapshot { get; private set; } = new ClanClientSnapshot();

		public static ClanHudSnapshot CurrentHudSnapshot { get; private set; } = new ClanHudSnapshot();

		public static ClanDirectorySnapshot CurrentDirectory { get; private set; } = new ClanDirectorySnapshot();

		public static bool IsDirectoryRequestPending => _pendingDirectoryRequestId > 0;

		internal static bool IsIdentityReady => _identityReady;

		public static event Action<ClanClientSnapshot>? SnapshotChanged;

		public static event Action<ClanHudSnapshot>? HudSnapshotChanged;

		public static event Action<ClanDirectorySnapshot>? DirectoryChanged;

		public static event Action<string>? StatusReceived;

		public static event Action<string, string>? ChatReceived;

		public static bool Send(ClanRequest request)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			try
			{
				request.Write(val);
			}
			catch (InvalidDataException ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Rejected invalid local clan request: " + ex.Message));
				NotifyStatus(ClanLocalization.Text("clan_status_invalid_request_server"));
				return false;
			}
			ZNet instance = ZNet.instance;
			ZRpc val2 = ((instance != null) ? instance.GetServerRPC() : null);
			if (val2 != null)
			{
				val2.Invoke(RequestRpc, new object[1] { val });
				return true;
			}
			ZNet instance2 = ZNet.instance;
			if (instance2 != null && instance2.IsServer())
			{
				val.SetPos(0);
				ClanRegistry.HandleRequest(null, ClanRequest.Read(val));
				return true;
			}
			NotifyStatus(ClanLocalization.Text("clan_status_server_not_connected"));
			return false;
		}

		public static void RequestSnapshot()
		{
			Send(ClanRequest.Simple(ClanRequestType.RequestSnapshot));
		}

		public static void RequestHudSnapshot(string clanId)
		{
			if (!string.IsNullOrWhiteSpace(clanId))
			{
				long hudSelectionRevision = 0L;
				long hudStateRevision = 0L;
				if (StringComparer.Ordinal.Equals(CurrentHudSnapshot.ClanId, clanId))
				{
					hudSelectionRevision = CurrentHudSnapshot.SelectionRevision;
					hudStateRevision = CurrentHudSnapshot.StateRevision;
				}
				Send(new ClanRequest
				{
					Type = ClanRequestType.RequestHud,
					ClanId = clanId,
					HudSelectionRevision = hudSelectionRevision,
					HudStateRevision = hudStateRevision
				});
			}
		}

		public static void Tick()
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			EnsureInitialSnapshotBootstrap();
			if (!_initialSnapshotBootstrapComplete && _initialSnapshotRetriesRemaining > 0 && realtimeSinceStartup >= _nextInitialSnapshotRetryAt && CanRunInitialSnapshotBootstrap())
			{
				_initialSnapshotRetriesRemaining--;
				_nextInitialSnapshotRetryAt = realtimeSinceStartup + 0.5f;
				RequestSnapshot();
			}
			if (_identityReady && _retryDirectoryWhenIdentityReady && realtimeSinceStartup >= _directoryIdentityRetryAt)
			{
				_retryDirectoryWhenIdentityReady = false;
				RequestDirectory();
			}
		}

		private static void EnsureInitialSnapshotBootstrap()
		{
			if (!_initialSnapshotBootstrapStarted && !_initialSnapshotBootstrapComplete && CanRunInitialSnapshotBootstrap())
			{
				_initialSnapshotBootstrapStarted = true;
				_identityReady = false;
				_initialSnapshotRetriesRemaining = 20;
				_nextInitialSnapshotRetryAt = Time.realtimeSinceStartup;
				if (CanRunInitialSnapshotBootstrap())
				{
					_nextInitialSnapshotRetryAt += 0.5f;
					RequestSnapshot();
				}
			}
		}

		private static bool CanRunInitialSnapshotBootstrap()
		{
			ZNet instance = ZNet.instance;
			if ((Object)(object)Game.instance != (Object)null && (Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)instance != (Object)null)
			{
				if (instance.GetServerRPC() == null)
				{
					return instance.IsServer();
				}
				return true;
			}
			return false;
		}

		public static long RequestDirectory()
		{
			_retryDirectoryWhenIdentityReady = false;
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null || (instance.GetServerRPC() == null && !instance.IsServer()))
			{
				_pendingDirectoryRequestId = 0L;
				NotifyStatus(ClanLocalization.Text("clan_status_server_not_connected"));
				return 0L;
			}
			long num = (_pendingDirectoryRequestId = NextRequestId());
			if (!Send(new ClanRequest
			{
				Type = ClanRequestType.RequestDirectory,
				RequestId = num
			}))
			{
				_pendingDirectoryRequestId = 0L;
				return 0L;
			}
			return num;
		}

		internal static long NextRequestId()
		{
			lock (RequestIdLock)
			{
				if (_nextRequestId == long.MaxValue)
				{
					_nextRequestId = 0L;
				}
				return ++_nextRequestId;
			}
		}

		public static void InvalidateDirectory()
		{
			_pendingDirectoryRequestId = 0L;
			_retryDirectoryWhenIdentityReady = true;
			_directoryIdentityRetryAt = Time.realtimeSinceStartup + 2f + 0.1f;
			CurrentDirectory = new ClanDirectorySnapshot();
			Publish(ClanRpc.DirectoryChanged, CurrentDirectory, "directory");
		}

		public static void NotifyStatus(string message)
		{
			Publish(ClanRpc.StatusReceived, ClanLocalization.ResolveStatus(message), "status");
		}

		public static bool TryPinPeerIdentity(ZNetPeer? peer, ClanPlayerRef player)
		{
			if (peer?.m_rpc == null)
			{
				return true;
			}
			if (!player.IsValid)
			{
				return false;
			}
			if (PeerIdentities.TryGetValue(peer.m_rpc, out var value))
			{
				return value == player;
			}
			PeerIdentities.Add(peer.m_rpc, player);
			return true;
		}

		public static bool TryGetPinnedPeerIdentity(ZNetPeer? peer, out ClanPlayerRef player)
		{
			player = default(ClanPlayerRef);
			if (peer?.m_rpc != null)
			{
				return PeerIdentities.TryGetValue(peer.m_rpc, out player);
			}
			return false;
		}

		public static void SendSnapshot(ZNetPeer? peer, ClanClientSnapshot snapshot)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(0);
			snapshot.Write(val);
			SendResponse(peer, val);
		}

		public static void SendHudSnapshot(ZNetPeer? peer, ClanHudSnapshot snapshot)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(6);
			snapshot.Write(val);
			SendResponse(peer, val);
		}

		public static void SendDirectorySnapshot(ZNetPeer? peer, ClanDirectorySnapshot snapshot)
		{
			int count = snapshot.PublicClans.Count;
			int count2 = snapshot.Players.Count;
			ZPackage val = CreateDirectoryResponse(snapshot, count, count2);
			if (val.Size() <= 524288)
			{
				SendResponse(peer, val);
				return;
			}
			snapshot.IsTruncated = true;
			if (string.IsNullOrWhiteSpace(snapshot.Status))
			{
				snapshot.Status = DirectoryTruncatedStatus;
			}
			count2 = FindLargestPlayerPrefix(snapshot, count, count2);
			val = CreateDirectoryResponse(snapshot, count, count2);
			if (val.Size() > 524288)
			{
				count2 = 0;
				count = FindLargestClanPrefix(snapshot, count);
				val = CreateDirectoryResponse(snapshot, count, count2);
			}
			if (val.Size() > 524288)
			{
				snapshot.Status = ClanLocalization.EncodeStatus("clan_status_directory_response_too_large");
				snapshot.IsTruncated = true;
				val = CreateDirectoryResponse(snapshot, 0, 0);
			}
			SendResponse(peer, val);
		}

		private static int FindLargestPlayerPrefix(ClanDirectorySnapshot snapshot, int clanCount, int maximumPlayerCount)
		{
			int num = 0;
			int num2 = maximumPlayerCount;
			int result = 0;
			while (num <= num2)
			{
				int num3 = num + (num2 - num) / 2;
				if (CreateDirectoryResponse(snapshot, clanCount, num3).Size() <= 524288)
				{
					result = num3;
					num = num3 + 1;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			return result;
		}

		private static int FindLargestClanPrefix(ClanDirectorySnapshot snapshot, int maximumClanCount)
		{
			int num = 0;
			int num2 = maximumClanCount;
			int result = 0;
			while (num <= num2)
			{
				int num3 = num + (num2 - num) / 2;
				if (CreateDirectoryResponse(snapshot, num3, 0).Size() <= 524288)
				{
					result = num3;
					num = num3 + 1;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			return result;
		}

		private static ZPackage CreateDirectoryResponse(ClanDirectorySnapshot snapshot, int clanCount, int playerCount)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(4);
			snapshot.Write(val, clanCount, playerCount);
			return val;
		}

		public static void BroadcastChat(ClanState clan, string senderName, string message)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			Dictionary<string, ZNetPeer> peers = BuildPeerLookup();
			ZPackage val = new ZPackage();
			val.Write(1);
			ClanDataRules.WriteClanId(val, clan.ClanId);
			ClanDataRules.WritePlayerName(val, senderName, "chat sender");
			ClanDataRules.WriteText(val, message, 400, "chat message", allowEmpty: false);
			foreach (ClanMember value in clan.Members.Values)
			{
				if (ClanRegistry.IsEffectiveMember(clan, value))
				{
					SendResponse(FindPeer(value.Player, peers), val, value.Player);
				}
			}
		}

		public static void BroadcastPing(ClanState clan, ClanPlayerRef sender, Vector3 position)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, ZNetPeer> peers = BuildPeerLookup();
			ZPackage val = new ZPackage();
			val.Write(2);
			ClanDataRules.WriteClanId(val, clan.ClanId);
			sender.Write(val);
			val.Write(position);
			foreach (ClanMember value in clan.Members.Values)
			{
				if (ClanRegistry.IsEffectiveMember(clan, value))
				{
					SendResponse(FindPeer(value.Player, peers), val, value.Player);
				}
			}
		}

		public static void BroadcastPosition(ClanState clan, ClanPlayerRef sender, Vector3 position)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, ZNetPeer> peers = BuildPeerLookup();
			ZPackage val = new ZPackage();
			val.Write(3);
			ClanDataRules.WriteClanId(val, clan.ClanId);
			sender.Write(val);
			val.Write(position);
			foreach (ClanMember value in clan.Members.Values)
			{
				if (!(value.Player == sender) && ClanRegistry.IsEffectiveMember(clan, value))
				{
					SendResponse(FindPeer(value.Player, peers), val, value.Player);
				}
			}
		}

		public static void BroadcastDirectoryInvalidation()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(5);
			if ((Object)(object)ZNet.instance != (Object)null)
			{
				foreach (ZNetPeer connectedPeer in ZNet.instance.GetConnectedPeers())
				{
					SendResponse(connectedPeer, val);
				}
			}
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				TryHandleResponsePackage(val);
			}
		}

		private static void SendResponse(ZNetPeer? peer, ZPackage package, ClanPlayerRef target = default(ClanPlayerRef))
		{
			try
			{
				if (peer != null)
				{
					peer.m_rpc.Invoke(ResponseRpc, new object[1] { package });
				}
				else if (!target.IsValid || ((Object)(object)Player.m_localPlayer != (Object)null && target == ClanPlayerRef.Local()))
				{
					TryHandleResponsePackage(package);
				}
			}
			catch (Exception ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)$"Failed to send clan response to {target}: {ex.Message}");
			}
		}

		private static ZNetPeer? FindPeer(ClanPlayerRef player, IReadOnlyDictionary<string, ZNetPeer> peers)
		{
			if (!player.IsValid || !peers.TryGetValue(player.Id, out ZNetPeer value))
			{
				return null;
			}
			return value;
		}

		private static Dictionary<string, ZNetPeer> BuildPeerLookup()
		{
			Dictionary<string, ZNetPeer> dictionary = new Dictionary<string, ZNetPeer>(StringComparer.Ordinal);
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return dictionary;
			}
			foreach (ZNetPeer connectedPeer in ZNet.instance.GetConnectedPeers())
			{
				ClanPlayerRef player;
				ClanPlayerRef clanPlayerRef = (TryGetPinnedPeerIdentity(connectedPeer, out player) ? player : ClanIdentity.FromPeer(connectedPeer));
				if (clanPlayerRef.IsValid)
				{
					dictionary[clanPlayerRef.Id] = connectedPeer;
				}
			}
			return dictionary;
		}

		private static void ClientHandleResponse(ZRpc rpc, ZPackage package)
		{
			TryHandleResponsePackage(package);
		}

		private static void TryHandleResponsePackage(ZPackage package)
		{
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			ClanResponseType clanResponseType = ClanResponseType.Snapshot;
			bool flag = false;
			try
			{
				package.SetPos(0);
				clanResponseType = (ClanResponseType)package.ReadInt();
				switch (clanResponseType)
				{
				case ClanResponseType.Snapshot:
				{
					ClanClientSnapshot clanClientSnapshot = ClanClientSnapshot.Read(package);
					RequirePackageConsumed(package);
					flag = true;
					clanClientSnapshot.Status = ClanLocalization.ResolveStatus(clanClientSnapshot.Status);
					ClanOperationResultCode resultCode = clanClientSnapshot.ResponseResultCode;
					if ((resultCode == ClanOperationResultCode.IdentityUnavailable || (uint)(resultCode - 8) <= 1u || resultCode == ClanOperationResultCode.SnapshotRateLimited) ? true : false)
					{
						if (clanClientSnapshot.ResponseRequestId > 0)
						{
							CopySnapshotPresentation(CurrentSnapshot, clanClientSnapshot);
							Publish(ClanRpc.SnapshotChanged, clanClientSnapshot, "snapshot");
						}
						if (!_initialSnapshotBootstrapComplete && _initialSnapshotRetriesRemaining > 0 && clanClientSnapshot.ResponseResultCode == ClanOperationResultCode.Unavailable)
						{
							_nextInitialSnapshotRetryAt = Time.realtimeSinceStartup + 0.5f;
						}
						else if (!_initialSnapshotBootstrapComplete && _initialSnapshotRetriesRemaining > 0 && clanClientSnapshot.ResponseResultCode == ClanOperationResultCode.SnapshotRateLimited)
						{
							_nextInitialSnapshotRetryAt = Time.realtimeSinceStartup + 2f + 0.1f;
						}
						Publish(ClanRpc.StatusReceived, clanClientSnapshot.Status, "status");
						break;
					}
					if (_initialSnapshotBootstrapComplete || clanClientSnapshot.ResponseResultCode != ClanOperationResultCode.Failed)
					{
						_initialSnapshotRetriesRemaining = 0;
						_initialSnapshotBootstrapStarted = true;
						_initialSnapshotBootstrapComplete = true;
					}
					bool num = clanClientSnapshot.ResponseResultCode == ClanOperationResultCode.IdentityRejected;
					_identityReady = !num;
					if (num)
					{
						_retryDirectoryWhenIdentityReady = false;
					}
					bool num2 = !StringComparer.Ordinal.Equals(CurrentSnapshot.ClanId, clanClientSnapshot.ClanId);
					CurrentSnapshot = clanClientSnapshot;
					if (num2)
					{
						CurrentHudSnapshot = new ClanHudSnapshot();
						Publish(ClanRpc.HudSnapshotChanged, CurrentHudSnapshot, "HUD snapshot");
					}
					ClanMap.OnSnapshotChanged(CurrentSnapshot);
					Publish(ClanRpc.SnapshotChanged, CurrentSnapshot, "snapshot");
					if (!string.IsNullOrWhiteSpace(CurrentSnapshot.Status))
					{
						Publish(ClanRpc.StatusReceived, CurrentSnapshot.Status, "status");
					}
					break;
				}
				case ClanResponseType.Chat:
				{
					string x = ClanDataRules.ReadClanId(package, "chat clan id");
					string first = ClanDataRules.ReadText(package, 64, "chat sender");
					string second = ClanDataRules.ReadText(package, 400, "chat message", allowEmpty: false);
					RequirePackageConsumed(package);
					flag = true;
					if (StringComparer.Ordinal.Equals(x, CurrentSnapshot.ClanId))
					{
						Publish(ClanRpc.ChatReceived, first, second, "chat");
					}
					break;
				}
				case ClanResponseType.MapPing:
				{
					string x3 = ClanDataRules.ReadClanId(package, "ping clan id");
					ClanPlayerRef sender = ClanPlayerRef.Read(package);
					Vector3 position2 = ClanDataRules.ReadFiniteVector(package, "map ping position");
					RequirePackageConsumed(package);
					flag = true;
					if (StringComparer.Ordinal.Equals(x3, CurrentSnapshot.ClanId))
					{
						ClanMap.OnMapPing(sender, position2);
					}
					break;
				}
				case ClanResponseType.PositionUpdate:
				{
					string x2 = ClanDataRules.ReadClanId(package, "position clan id");
					ClanPlayerRef player = ClanPlayerRef.Read(package);
					Vector3 position = ClanDataRules.ReadFiniteVector(package, "player position");
					RequirePackageConsumed(package);
					flag = true;
					if (StringComparer.Ordinal.Equals(x2, CurrentSnapshot.ClanId))
					{
						ClanMap.OnPositionUpdate(player, position);
					}
					break;
				}
				case ClanResponseType.Hud:
				{
					ClanHudSnapshot incoming = ClanHudSnapshot.Read(package);
					RequirePackageConsumed(package);
					flag = true;
					HandleHudSnapshot(incoming);
					break;
				}
				case ClanResponseType.Directory:
				{
					ClanDirectorySnapshot clanDirectorySnapshot = ClanDirectorySnapshot.Read(package);
					RequirePackageConsumed(package);
					flag = true;
					clanDirectorySnapshot.Status = ClanLocalization.ResolveStatus(clanDirectorySnapshot.Status);
					if (_pendingDirectoryRequestId <= 0 || clanDirectorySnapshot.RequestId != _pendingDirectoryRequestId)
					{
						break;
					}
					_pendingDirectoryRequestId = 0L;
					if (clanDirectorySnapshot.ResultCode == ClanOperationResultCode.IdentityUnavailable)
					{
						_retryDirectoryWhenIdentityReady = true;
						_directoryIdentityRetryAt = Time.realtimeSinceStartup + 2f + 0.1f;
						Publish(ClanRpc.StatusReceived, clanDirectorySnapshot.Status, "status");
						break;
					}
					if (clanDirectorySnapshot.ResultCode == ClanOperationResultCode.RateLimited)
					{
						_retryDirectoryWhenIdentityReady = true;
						_directoryIdentityRetryAt = Time.realtimeSinceStartup + 2f + 0.1f;
					}
					if (!clanDirectorySnapshot.IsTruncated)
					{
						ClanOperationResultCode resultCode = clanDirectorySnapshot.ResultCode;
						if (resultCode != ClanOperationResultCode.None && resultCode != ClanOperationResultCode.Success && clanDirectorySnapshot.PublicClans.Count == 0 && clanDirectorySnapshot.Players.Count == 0)
						{
							clanDirectorySnapshot.PublicClans.AddRange(CurrentDirectory.PublicClans);
							clanDirectorySnapshot.Players.AddRange(CurrentDirectory.Players);
							clanDirectorySnapshot.IsTruncated = CurrentDirectory.IsTruncated;
						}
					}
					CurrentDirectory = clanDirectorySnapshot;
					Publish(ClanRpc.DirectoryChanged, CurrentDirectory, "directory");
					if (!string.IsNullOrWhiteSpace(CurrentDirectory.Status))
					{
						Publish(ClanRpc.StatusReceived, CurrentDirectory.Status, "status");
					}
					break;
				}
				case ClanResponseType.DirectoryInvalidated:
					RequirePackageConsumed(package);
					flag = true;
					_pendingDirectoryRequestId = 0L;
					_retryDirectoryWhenIdentityReady = true;
					_directoryIdentityRetryAt = Time.realtimeSinceStartup + 0.1f;
					CurrentDirectory = new ClanDirectorySnapshot();
					Publish(ClanRpc.DirectoryChanged, CurrentDirectory, "directory");
					break;
				default:
					throw new InvalidOperationException($"Unknown clan response type {(int)clanResponseType}.");
				}
			}
			catch (Exception ex) when (!flag)
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Rejected malformed clan response: " + ex.Message));
			}
			catch (Exception arg)
			{
				ClanPlugin.ClanLogger.LogError((object)$"Failed to apply decoded clan {clanResponseType} response: {arg}");
			}
		}

		private static void CopySnapshotPresentation(ClanClientSnapshot source, ClanClientSnapshot target)
		{
			target.PrimaryClanId = source.PrimaryClanId;
			target.PrimaryClanName = source.PrimaryClanName;
			target.PrimaryRole = source.PrimaryRole;
			target.GuestClanId = source.GuestClanId;
			target.GuestClanName = source.GuestClanName;
			target.ClanId = source.ClanId;
			target.ClanName = source.ClanName;
			target.ClanDescription = source.ClanDescription;
			target.ClanEmblemKey = source.ClanEmblemKey;
			target.SelfRole = source.SelfRole;
			target.Roster.Clear();
			target.Roster.AddRange(source.Roster);
			target.Applications.Clear();
			target.Applications.AddRange(source.Applications);
			target.Invite = source.Invite;
			target.OwnApplicationClanId = source.OwnApplicationClanId;
			target.OwnApplicationClanName = source.OwnApplicationClanName;
		}

		private static void RequirePackageConsumed(ZPackage package)
		{
			if (package.GetPos() != package.Size())
			{
				throw new InvalidOperationException("Clan response contains unexpected trailing data.");
			}
		}

		private static void HandleHudSnapshot(ClanHudSnapshot incoming)
		{
			if (!StringComparer.Ordinal.Equals(incoming.ClanId, CurrentSnapshot.ClanId))
			{
				return;
			}
			if (incoming.ReplaceSelection)
			{
				CurrentHudSnapshot = incoming;
				Publish(ClanRpc.HudSnapshotChanged, CurrentHudSnapshot, "HUD snapshot");
			}
			else if (!StringComparer.Ordinal.Equals(incoming.ClanId, CurrentHudSnapshot.ClanId) || incoming.SelectionRevision != CurrentHudSnapshot.SelectionRevision)
			{
				ResetHudSnapshotAndRequestFull();
			}
			else
			{
				if (incoming.StateRevision == CurrentHudSnapshot.StateRevision)
				{
					return;
				}
				if (CurrentHudSnapshot.StateRevision == long.MaxValue || incoming.StateRevision != CurrentHudSnapshot.StateRevision + 1)
				{
					ResetHudSnapshotAndRequestFull();
					return;
				}
				int[] array = new int[incoming.Players.Count];
				for (int i = 0; i < incoming.Players.Count; i++)
				{
					string playerId = incoming.Players[i].PlayerId;
					int num = FindHudPlayerIndex(CurrentHudSnapshot, playerId);
					if (num < 0)
					{
						ResetHudSnapshotAndRequestFull();
						return;
					}
					array[i] = num;
				}
				for (int j = 0; j < incoming.Players.Count; j++)
				{
					ClanHudPlayerSummary clanHudPlayerSummary = incoming.Players[j];
					ClanHudPlayerSummary clanHudPlayerSummary2 = CurrentHudSnapshot.Players[array[j]];
					clanHudPlayerSummary2.HasHealth = clanHudPlayerSummary.HasHealth;
					clanHudPlayerSummary2.CurrentHealth = clanHudPlayerSummary.CurrentHealth;
					clanHudPlayerSummary2.MaxHealth = clanHudPlayerSummary.MaxHealth;
				}
				CurrentHudSnapshot.StateRevision = incoming.StateRevision;
				CurrentHudSnapshot.ReplaceSelection = true;
				Publish(ClanRpc.HudSnapshotChanged, CurrentHudSnapshot, "HUD snapshot");
			}
		}

		private static int FindHudPlayerIndex(ClanHudSnapshot snapshot, string playerId)
		{
			for (int i = 0; i < snapshot.Players.Count; i++)
			{
				if (StringComparer.Ordinal.Equals(snapshot.Players[i].PlayerId, playerId))
				{
					return i;
				}
			}
			return -1;
		}

		private static void ResetHudSnapshotAndRequestFull()
		{
			CurrentHudSnapshot = new ClanHudSnapshot();
			Publish(ClanRpc.HudSnapshotChanged, CurrentHudSnapshot, "HUD snapshot");
			string clanId = CurrentSnapshot.ClanId;
			if (string.IsNullOrWhiteSpace(clanId) || _hudRecoveryRequestInProgress)
			{
				return;
			}
			try
			{
				_hudRecoveryRequestInProgress = true;
				RequestHudSnapshot(clanId);
			}
			finally
			{
				_hudRecoveryRequestInProgress = false;
			}
		}

		private static void ServerHandleRequest(ZNetPeer peer, ZRpc rpc, ZPackage package)
		{
			try
			{
				if (package.Size() > 16384)
				{
					ClanPlugin.ClanLogger.LogWarning((object)$"Rejected oversized clan request ({package.Size()} bytes) from peer {peer.m_uid}.");
					return;
				}
				package.SetPos(0);
				ClanRequest clanRequest = ClanRequest.Read(package);
				if (clanRequest.Type == ClanRequestType.RequestDirectory && !ConsumeRequest(rpc, DirectoryRequestBudgets, 1, 2f))
				{
					SendDirectorySnapshot(peer, new ClanDirectorySnapshot
					{
						RequestId = clanRequest.RequestId,
						ResultCode = ClanOperationResultCode.RateLimited,
						Status = DirectoryRateLimitedStatus
					});
				}
				else if (clanRequest.Type == ClanRequestType.RequestSnapshot && !ConsumeRequest(rpc, SnapshotRequestBudgets, 5, 2f))
				{
					SendSnapshot(peer, new ClanClientSnapshot
					{
						Status = SnapshotRateLimitedStatus,
						ResponseResultCode = ClanOperationResultCode.SnapshotRateLimited
					});
				}
				else if (clanRequest.Type != ClanRequestType.RequestHud || ConsumeRequest(rpc, HudRequestBudgets, 5, 2f))
				{
					ClanRegistry.HandleRequest(peer, clanRequest);
				}
			}
			catch (Exception ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Rejected malformed clan request: " + ex.Message));
			}
		}

		private static void ResetSession()
		{
			CurrentSnapshot = new ClanClientSnapshot();
			CurrentHudSnapshot = new ClanHudSnapshot();
			CurrentDirectory = new ClanDirectorySnapshot();
			_pendingDirectoryRequestId = 0L;
			_initialSnapshotRetriesRemaining = 0;
			_nextInitialSnapshotRetryAt = 0f;
			_initialSnapshotBootstrapStarted = false;
			_initialSnapshotBootstrapComplete = false;
			_identityReady = false;
			_retryDirectoryWhenIdentityReady = false;
			_directoryIdentityRetryAt = 0f;
			_hudRecoveryRequestInProgress = false;
			DirectoryRequestBudgets.Clear();
			SnapshotRequestBudgets.Clear();
			HudRequestBudgets.Clear();
			MutationRequestBudgets.Clear();
			PeerIdentities.Clear();
			ClanApi.ResetSession();
			ClanRegistry.ResetOnlinePresence();
			ClanMap.ResetSession();
			ClanPanelController.ResetSearchState();
			Publish(ClanRpc.SnapshotChanged, CurrentSnapshot, "snapshot");
			Publish(ClanRpc.HudSnapshotChanged, CurrentHudSnapshot, "HUD snapshot");
			Publish(ClanRpc.DirectoryChanged, CurrentDirectory, "directory");
		}

		private static void Publish<T>(Action<T>? subscribers, T value, string eventName)
		{
			if (subscribers == null)
			{
				return;
			}
			Delegate[] invocationList = subscribers.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action<T> action = (Action<T>)invocationList[i];
				try
				{
					action(value);
				}
				catch (Exception arg)
				{
					ClanPlugin.ClanLogger.LogWarning((object)$"Clan RPC {eventName} subscriber failed: {arg}");
				}
			}
		}

		private static void Publish<TFirst, TSecond>(Action<TFirst, TSecond>? subscribers, TFirst first, TSecond second, string eventName)
		{
			if (subscribers == null)
			{
				return;
			}
			Delegate[] invocationList = subscribers.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action<TFirst, TSecond> action = (Action<TFirst, TSecond>)invocationList[i];
				try
				{
					action(first, second);
				}
				catch (Exception arg)
				{
					ClanPlugin.ClanLogger.LogWarning((object)$"Clan RPC {eventName} subscriber failed: {arg}");
				}
			}
		}

		internal static bool ConsumeMutationRequest(ClanPlayerRef actor)
		{
			if (!actor.IsValid)
			{
				return false;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (MutationRequestBudgets.Count >= 256 && !MutationRequestBudgets.ContainsKey(actor.Id))
			{
				PruneExpiredMutationBudgets(realtimeSinceStartup);
			}
			if (!MutationRequestBudgets.TryGetValue(actor.Id, out RequestBudget value))
			{
				value = new RequestBudget(realtimeSinceStartup);
				MutationRequestBudgets.Add(actor.Id, value);
			}
			return ConsumeBudget(value, 6, 5f, realtimeSinceStartup);
		}

		private static void PruneExpiredMutationBudgets(float now)
		{
			List<string> list = null;
			foreach (KeyValuePair<string, RequestBudget> mutationRequestBudget in MutationRequestBudgets)
			{
				float num = now - mutationRequestBudget.Value.WindowStartedAt;
				if (num >= 5f || num < 0f)
				{
					if (list == null)
					{
						list = new List<string>();
					}
					list.Add(mutationRequestBudget.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (string item in list)
			{
				MutationRequestBudgets.Remove(item);
			}
		}

		private static bool ConsumeRequest(ZRpc rpc, IDictionary<ZRpc, RequestBudget> budgets, int maximumRequests, float windowSeconds)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!budgets.TryGetValue(rpc, out RequestBudget value))
			{
				value = new RequestBudget(realtimeSinceStartup);
				budgets.Add(rpc, value);
			}
			return ConsumeBudget(value, maximumRequests, windowSeconds, realtimeSinceStartup);
		}

		private static bool ConsumeBudget(RequestBudget budget, int maximumRequests, float windowSeconds, float? nowOverride = null)
		{
			float num = nowOverride ?? Time.realtimeSinceStartup;
			if (num - budget.WindowStartedAt >= windowSeconds || num < budget.WindowStartedAt)
			{
				budget.WindowStartedAt = num;
				budget.Requests = 0;
			}
			if (budget.Requests >= maximumRequests)
			{
				return false;
			}
			budget.Requests++;
			return true;
		}
	}
	internal static class ClanMap
	{
		[HarmonyPatch(typeof(Chat), "SendPing")]
		private static class SendClanPingPatch
		{
			private static bool Prefix(Vector3 position)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return !TrySendClanPing(position);
			}
		}

		[HarmonyPatch(typeof(Chat), "RPC_ChatMessage")]
		private static class ClearClanPingPatch
		{
			private static void Prefix(Chat __instance, long sender)
			{
				Minimap instance = Minimap.instance;
				WorldTextInstance val = FindWorldText(__instance, sender);
				if (val == null || !ClanPingTexts.Remove(val) || (Object)(object)instance == (Object)null || !TryReadMinimapField<List<WorldTextInstance>>(instance, ref _tempShoutsField, "m_tempShouts", out var value) || !TryReadMinimapField<List<PinData>>(instance, ref _pingPinsField, "m_pingPins", out var value2))
				{
					return;
				}
				Sprite val2 = FindMinimapSprite(instance, (PinType)12);
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				for (int i = 0; i < value.Count && i < value2.Count; i++)
				{
					PinData pin = value2[i];
					if (value[i] == val)
					{
						SetPinAppearance(pin, val2, doubleSize: false);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Minimap), "UpdatePlayerPins")]
		private static class ClanMemberPinPatch
		{
			private static void Postfix(Minimap __instance)
			{
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: 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)
				EnsureSprites();
				if ((Object)(object)_clanPlayerIcon == (Object)null || !TryReadMinimapField(__instance, ref _tempPlayerInfoField, "m_tempPlayerInfo", out var value) || !TryReadMinimapField<List<PinData>>(__instance, ref _playerPinsField, "m_playerPins", out var value2))
				{
					return;
				}
				Sprite val = FindMinimapSprite(__instance, (PinType)10);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				for (int i = 0; i < value.Count && i < value2.Count; i++)
				{
					PinData val2 = value2[i];
					PlayerInfo val3 = value[i];
					if (!(val2.m_name != val3.m_name))
					{
						if (IsClanPlayer(val3))
						{
							SetPinAppearance(val2, _clanPlayerIcon, doubleSize: true);
						}
						else if ((Object)(object)val2.m_icon == (Object)(object)_clanPlayerIcon)
						{
							SetPinAppearance(val2, val, doubleSize: false);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "GetOtherPublicPlayers")]
		private static class AddClanPositionsToMinimapPatch
		{
			private static void Postfix(ZNet __instance, List<PlayerInfo> playerList)
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: 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_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				Minimap instance = Minimap.instance;
				if (!ClanPlugin.ShareClanPositions.Value.IsOn() || !ClanRpc.CurrentSnapshot.HasClan || (Object)(object)instance == (Object)null || !TryReadMinimapField(instance, ref _tempPlayerInfoField, "m_tempPlayerInfo", out var value) || playerList != value)
				{
					return;
				}
				for (int i = 0; i < playerList.Count; i++)
				{
					PlayerInfo val = playerList[i];
					if (ClanIdentity.TryMatchRosterPlayer(val, ClanRpc.CurrentSnapshot.Roster, out var player) && ForcedPositions.TryGetValue(player.Id, out var value2))
					{
						val.m_position = value2;
						playerList[i] = val;
					}
				}
				foreach (PlayerInfo player3 in __instance.GetPlayerList())
				{
					if (!player3.m_publicPosition)
					{
						ZDOID characterID = player3.m_characterID;
						if (!((ZDOID)(ref characterID)).IsNone() && !(player3.m_characterID == __instance.LocalPlayerCharacterID) && ClanIdentity.TryMatchRosterPlayer(player3, ClanRpc.CurrentSnapshot.Roster, out var player2) && ForcedPositions.TryGetValue(player2.Id, out var value3))
						{
							PlayerInfo item = player3;
							item.m_publicPosition = true;
							item.m_position = value3;
							playerList.Add(item);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(Minimap), "UpdatePingPins")]
		private static class ClanPingPinPatch
		{
			private static void Postfix(Minimap __instance)
			{
				EnsureSprites();
				if ((Object)(object)_clanPingIcon == (Object)null || !TryReadMinimapField<List<WorldTextInstance>>(__instance, ref _tempShoutsField, "m_tempShouts", out var value) || !TryReadMinimapField<List<PinData>>(__instance, ref _pingPinsField, "m_pingPins", out var value2))
				{
					return;
				}
				for (int i = 0; i < value.Count && i < value2.Count; i++)
				{
					PinData pin = value2[i];
					WorldTextInstance key = value[i];
					if (ClanPingTexts.TryGetValue(key, out object _))
					{
						SetPinAppearance(pin, _clanPingIcon, doubleSize: true);
					}
				}
			}
		}

		private const float PositionSendInterval = 2f;

		private const float PositionMoveThreshold = 1f;

		private const float PositionHeartbeatInterval = 10f;

		private const string ClanPingHintName = "ClanPing";

		private const string PingHintName = "PingPanel";

		private static ConditionalWeakTable<WorldTextInstance, object> ClanPingTexts = new ConditionalWeakTable<WorldTextInstance, object>();

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

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

		private static readonly List<string> StalePositionIds = new List<string>();

		private static FieldRef<Minimap, List<PinData>>? _pingPinsField = CreateMinimapFieldAccessor<List<PinData>>("m_pingPins");

		private static FieldRef<Minimap, List<PinData>>? _playerPinsField = CreateMinimapFieldAccessor<List<PinData>>("m_playerPins");

		private static FieldRef<Minimap, List<WorldTextInstance>>? _tempShoutsField = CreateMinimapFieldAccessor<List<WorldTextInstance>>("m_tempShouts");

		private static FieldRef<Minimap, List<PlayerInfo>>? _tempPlayerInfoField = CreateMinimapFieldAccessor<List<PlayerInfo>>("m_tempPlayerInfo");

		private static Sprite? _clanPlayerIcon;

		private static Sprite? _clanPingIcon;

		private static Minimap? _clanPingHintOwner;

		private static GameObject? _clanPingHint;

		private static TMP_Text? _clanPingHintLabel;

		private static float _nextPositionSendTime;

		private static Vector3 _lastSentPosition = Vector3.positiveInfinity;

		private static float _lastPositionSentTime = float.NegativeInfinity;

		private static string _effectiveClanId = "";

		private static bool _positionSharingActive;

		private static readonly Color ClanPingColor = new Color(1f, 0.78f, 0.25f, 1f);

		private static FieldRef<Minimap, T>? CreateMinimapFieldAccessor<T>(string fieldName) where T : class
		{
			try
			{
				return AccessTools.FieldRefAccess<Minimap, T>(fieldName);
			}
			catch (Exception ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Clan map integration for " + fieldName + " is unavailable: " + ex.Message));
				return null;
			}
		}

		private static bool TryReadMinimapField<T>(Minimap minimap, ref FieldRef<Minimap, T>? accessor, string fieldName, out T value) where T : class
		{
			value = null;
			FieldRef<Minimap, T> val = accessor;
			if (val == null)
			{
				return false;
			}
			try
			{
				value = val.Invoke(minimap);
				if (value != null)
				{
					return true;
				}
				accessor = null;
				ClanPlugin.ClanLogger.LogWarning((object)("Clan map integration for " + fieldName + " was disabled because the field was null."));
				return false;
			}
			catch (Exception ex)
			{
				accessor = null;
				ClanPlugin.ClanLogger.LogWarning((object)("Clan map integration for " + fieldName + " was disabled: " + ex.Message));
				return false;
			}
		}

		public static void ResetSession()
		{
			ForcedPositions.Clear();
			ClanPlayerIds.Clear();
			RestoreClanIcons();
			DestroyClanPingHint();
			DestroyGeneratedSprite(ref _clanPlayerIcon);
			DestroyGeneratedSprite(ref _clanPingIcon);
			ClanPingTexts = new ConditionalWeakTable<WorldTextInstance, object>();
			_effectiveClanId = "";
			_positionSharingActive = false;
			ResetPositionTimer();
		}

		public static void OnSnapshotChanged(ClanClientSnapshot snapshot)
		{
			ClanPlayerIds.Clear();
			foreach (ClanPlayerSummary item in snapshot.Roster)
			{
				if (item.IsOnline)
				{
					ClanPlayerIds.Add(item.Id);
				}
			}
			bool flag = !string.Equals(_effectiveClanId, snapshot.ClanId, StringComparison.Ordinal);
			if (!ClanPlugin.ShareClanPositions.Value.IsOn() || !snapshot.HasClan || flag)
			{
				ForcedPositions.Clear();
				if (flag)
				{
					RestoreClanPlayerIcons();
				}
				ResetPositionTimer();
			}
			_effectiveClanId = (snapshot.HasClan ? snapshot.ClanId : "");
			if (!ClanPlugin.ShareClanPositions.Value.IsOn() || !snapshot.HasClan)
			{
				RestoreClanPlayerIcons();
				_positionSharingActive = false;
				return;
			}
			_positionSharingActive = true;
			StalePositionIds.Clear();
			foreach (string key in ForcedPositions.Keys)
			{
				if (!ClanPlayerIds.Contains(key))
				{
					StalePositionIds.Add(key);
				}
			}
			foreach (string stalePositionId in StalePositionIds)
			{
				ForcedPositions.Remove(stalePositionId);
			}
			StalePositionIds.Clear();
		}

		public static void Tick()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			UpdateClanPingHint();
			if (!ClanPlugin.ShareClanPositions.Value.IsOn() || !ClanRpc.CurrentSnapshot.HasClan || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				if (ForcedPositions.Count != 0)
				{
					ForcedPositions.Clear();
				}
				if (_positionSharingActive)
				{
					RestoreClanPlayerIcons();
				}
				_positionSharingActive = false;
				ResetPositionTimer();
				return;
			}
			_positionSharingActive = true;
			if (!(Time.time < _nextPositionSendTime))
			{
				Vector3 position = ((Component)Player.m_localPlayer).transform.position;
				bool num = Vector3.Distance(position, _lastSentPosition) >= 1f;
				bool flag = Time.time < _lastPositionSentTime || Time.time - _lastPositionSentTime >= 10f;
				if (!num && !flag)
				{
					_nextPositionSendTime = Time.time + 2f;
					return;
				}
				_lastSentPosition = position;
				_lastPositionSentTime = Time.time;
				_nextPositionSendTime = Time.time + 2f;
				ClanRpc.Send(new ClanRequest
				{
					Type = ClanRequestType.UpdatePosition,
					ClanId = ClanRpc.CurrentSnapshot.ClanId,
					Position = position
				});
			}
		}

		private static void UpdateClanPingHint()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.m_largeRoot == (Object)null)
			{
				return;
			}
			KeyboardShortcut value = ClanPlugin.ClanPingModifierKey.Value;
			KeyCode mainKey = ((KeyboardShortcut)(ref value)).MainKey;
			if (!ClanRpc.CurrentSnapshot.HasClan || (int)mainKey == 0 || PlatformPrefs.GetInt("KeyHints", 1) != 1 || !instance.m_largeRoot.activeInHierarchy)
			{
				if ((Object)(object)_clanPingHint != (Object)null && _clanPingHint.activeSelf)
				{
					_clanPingHint.SetActive(false);
					MarkClanPingHintLayoutForRebuild();
				}
				return;
			}
			if ((Object)(object)_clanPingHintOwner != (Object)(object)instance || (Object)(object)_clanPingHint == (Object)null)
			{
				BuildClanPingHint(instance);
			}
			if ((Object)(object)_clanPingHint == (Object)null)
			{
				return;
			}
			if (!_clanPingHint.activeSelf)
			{
				_clanPingHint.SetActive(true);
				MarkClanPingHintLayoutForRebuild();
			}
			if (!((Object)(object)_clanPingHintLabel == (Object)null))
			{
				string text = ClanLocalization.Format("clan_map_ping_hint", FormatHintShortcut(value));
				if (!string.Equals(_clanPingHintLabel.text, text, StringComparison.Ordinal))
				{
					_clanPingHintLabel.text = text;
					MarkClanPingHintLayoutForRebuild();
				}
			}
		}

		private static void BuildClanPingHint(Minimap minimap)
		{
			DestroyClanPingHint();
			Transform val = minimap.m_largeRoot.transform.Find("KeyHints/keyboard_hints");
			Transform val2 = ((val != null) ? val.Find("PingPanel") : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				return;
			}
			Transform val3 = val.Find("ClanPing");
			GameObject val4 = (((Object)(object)val3 != (Object)null) ? ((Component)val3).gameObject : Object.Instantiate<GameObject>(((Component)val2).gameObject, val, false));
			((Object)val4).name = "ClanPing";
			val4.transform.SetSiblingIndex(val2.GetSiblingIndex());
			val4.SetActive(true);
			HorizontalLayoutGroup component = val4.GetComponent<HorizontalLayoutGroup>();
			if ((Object)(object)component != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)component).spacing = -4f;
			}
			Transform obj = val4.transform.Find("Label");
			TMP_Text val5 = ((obj != null) ? ((Component)obj).GetComponent<TMP_Text>() : null) ?? val4.GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)val5 == (Object)null)
			{
				if ((Object)(object)val3 == (Object)null)
				{
					Object.Destroy((Object)(object)val4);
				}
			}
			else
			{
				_clanPingHintOwner = minimap;
				_clanPingHint = val4;
				_clanPingHintLabel = val5;
				MarkClanPingHintLayoutForRebuild();
			}
		}

		private static void MarkClanPingHintLayoutForRebuild()
		{
			GameObject? clanPingHint = _clanPingHint;
			Transform obj = ((clanPingHint != null) ? clanPingHint.transform.parent : null);
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			if (val != null)
			{
				LayoutRebuilder.MarkLayoutForRebuild(val);
			}
		}

		private unsafe static string FormatHintShortcut(KeyboardShortcut shortcut)
		{
			return ((object)(*(KeyboardShortcut*)(&shortcut))/*cast due to .constrained prefix*/).ToString().Replace("LeftShift", "Shift").Replace("RightShift", "Shift")
				.Replace("LeftControl", "Ctrl")
				.Replace("RightControl", "Ctrl")
				.Replace("LeftAlt", "Alt")
				.Replace("RightAlt", "Alt");
		}

		private static void DestroyClanPingHint()
		{
			if ((Object)(object)_clanPingHint != (Object)null)
			{
				Object.Destroy((Object)(object)_clanPingHint);
			}
			_clanPingHintOwner = null;
			_clanPingHint = null;
			_clanPingHintLabel = null;
		}

		public static void OnMapPing(ClanPlayerRef sender, Vector3 position)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_006c: 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)
			Chat instance = Chat.instance;
			if (!((Object)(object)instance == (Object)null) && sender.IsValid && IsClanPlayer(sender))
			{
				EnsureSprites();
				long num = FindTalkerId(sender);
				UserInfo val = new UserInfo
				{
					Name = (string.IsNullOrWhiteSpace(sender.Name) ? ClanLocalization.Text("clan_name_fallback") : sender.Name),
					UserId = new PlatformUserID(sender.PlatformId)
				};
				instance.OnNewChatMessage((GameObject)null, num, position, (Type)3, val, "");
				WorldTextInstance val2 = FindWorldText(instance, num);
				if (val2 != null)
				{
					((Graphic)val2.m_textMeshField).color = ClanPingColor;
					ClanPingTexts.Remove(val2);
					ClanPingTexts.Add(val2, Array.Empty<object>());
				}
			}
		}

		private static WorldTextInstance? FindWorldText(Chat chat, long talkerId)
		{
			foreach (WorldTextInstance worldText in chat.WorldTexts)
			{
				if (worldText.m_talkerID == talkerId)
				{
					return worldText;
				}
			}
			return null;
		}

		public static void OnPositionUpdate(ClanPlayerRef player, Vector3 position)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (ClanPlugin.ShareClanPositions.Value.IsOn() && ClanRpc.CurrentSnapshot.HasClan && player.IsValid && !(player == ClanPlayerRef.Local()) && IsClanPlayer(player))
			{
				ForcedPositions[player.Id] = position;
			}
		}

		private static bool TrySendClanPing(Vector3 position)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (!ClanRpc.CurrentSnapshot.HasClan || (Object)(object)Player.m_localPlayer == (Object)null || !ClanPlugin.ClanPingModifierKey.Value.IsKeyHeld())
			{
				return false;
			}
			position.y = ((Component)Player.m_localPlayer).transform.position.y;
			ClanRpc.Send(new ClanRequest
			{
				Type = ClanRequestType.SendClanPing,
				ClanId = ClanRpc.CurrentSnapshot.ClanId,
				Position = position
			});
			return true;
		}

		private static void ResetPositionTimer()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			_nextPositionSendTime = 0f;
			_lastSentPosition = Vector3.positiveInfinity;
			_lastPositionSentTime = float.NegativeInfinity;
		}

		private static bool IsClanPlayer(PlayerInfo player)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (ClanPlugin.ShareClanPositions.Value.IsOn() && ClanIdentity.TryMatchRosterPlayer(player, ClanRpc.CurrentSnapshot.Roster, out var player2))
			{
				return ClanPlayerIds.Contains(player2.Id);
			}
			return false;
		}

		private static bool IsClanPlayer(ClanPlayerRef player)
		{
			if (player.IsValid)
			{
				return ClanPlayerIds.Contains(player.Id);
			}
			return false;
		}

		private static void RestoreClanIcons()
		{
			RestoreClanPlayerIcons();
			Minimap instance = Minimap.instance;
			if ((Object)(object)_clanPingIcon == (Object)null || (Object)(object)instance == (Object)null || !TryReadMinimapField<List<PinData>>(instance, ref _pingPinsField, "m_pingPins", out var value))
			{
				return;
			}
			Sprite val = FindMinimapSprite(instance, (PinType)12);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			foreach (PinData item in value)
			{
				if (!((Object)(object)item.m_icon != (Object)(object)_clanPingIcon))
				{
					SetPinAppearance(item, val, doubleSize: false);
				}
			}
		}

		private static void RestoreClanPlayerIcons()
		{
			Minimap instance = Minimap.instance;
			if ((Object)(object)_clanPlayerIcon == (Object)null || (Object)(object)instance == (Object)null || !TryReadMinimapField<List<PinData>>(instance, ref _playerPinsField, "m_playerPins", out var value))
			{
				return;
			}
			Sprite val = FindMinimapSprite(instance, (PinType)10);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			foreach (PinData item in value)
			{
				if (!((Object)(object)item.m_icon != (Object)(object)_clanPlayerIcon))
				{
					SetPinAppearance(item, val, doubleSize: false);
				}
			}
		}

		private static void SetPinAppearance(PinData pin, Sprite? icon, bool doubleSize)
		{
			pin.m_icon = icon;
			pin.m_doubleSize = doubleSize;
			if ((Object)(object)pin.m_iconElement != (Object)null)
			{
				pin.m_iconElement.sprite = icon;
			}
		}

		private static Sprite? FindMinimapSprite(Minimap minimap, PinType type)
		{
			//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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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 (minimap.m_icons == null)
			{
				return null;
			}
			foreach (SpriteData icon in minimap.m_icons)
			{
				if (icon.m_name == type)
				{
					return icon.m_icon;
				}
			}
			return null;
		}

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

		private static long FindTalkerId(ClanPlayerRef player)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance != (Object)null)
			{
				foreach (PlayerInfo onlinePlayer in ClanIdentity.GetOnlinePlayers())
				{
					if (ClanIdentity.TryMatchRosterPlayer(onlinePlayer, ClanRpc.CurrentSnapshot.Roster, out var player2) && player2 == player)
					{
						ZDOID characterID = onlinePlayer.m_characterID;
						return ((ZDOID)(ref characterID)).UserID;
					}
				}
			}
			long num = 1469598103934665603L;
			string id = player.Id;
			foreach (char c in id)
			{
				num ^= c;
				num *= 1099511628211L;
			}
			return num switch
			{
				0L => 1L, 
				long.MinValue => long.MaxValue, 
				_ => Math.Abs(num), 
			};
		}

		private static void EnsureSprites()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if ((!((Object)(object)_clanPlayerIcon != (Object)null) || !((Object)(object)_clanPingIcon != (Object)null)) && (int)SystemInfo.graphicsDeviceType != 4)
			{
				if (_clanPlayerIcon == null)
				{
					_clanPlayerIcon = CreateCircleSprite("Clan Player Icon", ClanUiFactory.GetClanColor(), Color.white);
				}
				if (_clanPingIcon == null)
				{
					_clanPingIcon = CreateDiamondSprite("Clan Ping Icon", ClanPingColor, Color.white);
				}
			}
		}

		private static Sprite CreateCircleSprite(string name, Color fill, Color accent)
		{
			//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_001d: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false)
			{
				name = name + " Texture"
			};
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0f, 0f, 0f, 0f);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(31.5f, 31.5f);
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 64; j++)
				{
					float num = Vector2.Distance(new Vector2((float)j, (float)i), val3);
					Color val4 = val2;
					if (num <= 27f)
					{
						val4 = ((num > 22f) ? accent : fill);
					}
					if (num <= 7f)
					{
						val4 = accent;
					}
					val.SetPixel(j, i, val4);
				}
			}
			val.Apply();
			return Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 100f);
		}

		private static Sprite CreateDiamondSprite(string name, Color fill, Color accent)
		{
			//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_001d: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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_0072: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false)
			{
				name = name + " Texture"
			};
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0f, 0f, 0f, 0f);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(31.5f, 31.5f);
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 64; j++)
				{
					float num = Math.Abs((float)j - val3.x) + Math.Abs((float)i - val3.y);
					Color val4 = val2;
					if (num <= 27f)
					{
						val4 = ((num > 22f) ? accent : fill);
					}
					if (num <= 7f)
					{
						val4 = accent;
					}
					val.SetPixel(j, i, val4);
				}
			}
			val.Apply();
			return Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 100f);
		}
	}
	internal static class ClanHud
	{
		private enum HudPointerMode
		{
			None,
			Collapse,
			HeaderPending,
			Drag
		}

		private sealed class HudRowView
		{
			public GameObject Root;

			public RectTransform Rect;

			public Text Label;

			public RectTransform Bar;

			public RectTransform SlowFill;

			public RectTransform FastFill;

			public Text Health;

			public string PlayerId = "";

			public float BarWidth = 100f;

			public float FastRatio;

			public float SlowRatio;

			public float SlowTargetRatio;

			public float SlowDelayUntil;
		}

		private const int MaxDisplayedMembers = 10;

		private const float RequestIntervalSeconds = 0.5f;

		private const float HeaderHeight = 42f;

		private const float HeaderToggleSize = 26f;

		private const float HeaderToggleGap = 7f;

		private const float HeaderRowGap = 5f;

		private const float RowHeight = 26f;

		private const float RowGap = 3f;

		private const float ColumnGap = 7f;

		private const float HudRightGap = 7f;

		private const float MaximumLabelWidth = 190f;

		private const float MinimumBarWidth = 100f;

		private const float MaximumBarWidth = 220f;

		private const float BarHeight = 20f;

		private const float MaximumHudWidth = 450f;

		private const float HealthLogBaseline = 100f;

		private const float HealthLogReference = 1000f;

		private const float SlowHealthDelaySeconds = 0.35f;

		private const float SlowHealthDrainPerSecond = 0.6f;

		private const float SafeAreaGap = 6f;

		private const float HeaderDragThresholdPixels = 5f;

		private static readonly Vector2 DefaultNormalizedPosition = new Vector2(0.015f, 0.32f);

		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 static readonly Color HeaderNameColor = ClanUiFactory.GetClanColor();

		private static readonly Color HeaderNameHoverColor = Color.Lerp(HeaderNameColor, Color.white, 0.35f);

		private static readonly Color HealthBackgroundColor = new Color(0f, 0f, 0f, 0.484f);

		private static readonly Color HealthSlowColor = new Color(1f, 0.8482759f, 0f, 1f);

		private static readonly Color HealthFastColor = new Color(1f, 0.333f, 0.333f, 1f);

		private static readonly Color RowTextColor = new Color(0.96f, 0.93f, 0.84f, 1f);

		private static readonly List<RaycastResult> UiRaycastResults = new List<RaycastResult>();

		private static GameObject? _root;

		private static RectTransform? _rootRect;

		private static RectTransform? _headerRect;

		private static Text? _headerClanName;

		private static Image? _headerDragSurface;

		private static RectTransform? _collapseButtonRect;

		private static Image? _collapseIcon;

		private static HudRowView[] _rows = Array.Empty<HudRowView>();

		private static float _nextRequestTime;

		private static string _displayedClanId = "";

		private static int _lastScreenWidth;

		private static int _lastScreenHeight;

		private static Rect _lastSafeArea;

		private static Vector2 _lastHudScale;

		private static bool _isWritingPosition;

		private static HudPointerMode _pointerMode;

		private static bool _restoreChatFocusAfterPointer;

		private static Vector2 _headerPressPosition;

		private static Vector2 _dragPointerOffset;

		private static Camera? _dragCamera;

		private static Transform? _trackedHudParent;

		private static bool _lastHudParentActive;

		private static Vector2 _lastHudParentSize;

		private static EventSystem? _uiRaycastEventSystem;

		private static PointerEventData? _uiRaycastPointerData;

		public static void Init()
		{
			GUIManager.OnCustomGUIAvailable += Rebuild;
			ClanRpc.SnapshotChanged += OnSnapshotChanged;
			ClanRpc.HudSnapshotChanged += OnHudSnapshotChanged;
			ClanPlugin.ClanHudPosition.SettingChanged += OnHudPositionChanged;
			ClanPlugin.ClanHudPlayerListCollapsed.SettingChanged += OnPlayerListCollapsedChanged;
			ClanPlugin.ShowClanHud.SettingChanged += OnShowHudChanged;
			ClanLocalization.LanguageChanged += OnLanguageChanged;
			Rebuild();
		}

		public static void Dispose()
		{
			//IL_017c: 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_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			GUIManager.OnCustomGUIAvailable -= Rebuild;
			ClanRpc.SnapshotChanged -= OnSnapshotChanged;
			ClanRpc.HudSnapshotChanged -= OnHudSnapshotChanged;
			ClanPlugin.ClanHudPosition.SettingChanged -= OnHudPositionChanged;
			ClanPlugin.ClanHudPlayerListCollapsed.SettingChanged -= OnPlayerListCollapsedChanged;
			ClanPlugin.ShowClanHud.SettingChanged -= OnShowHudChanged;
			ClanLocalization.LanguageChanged -= OnLanguageChanged;
			_pointerMode = HudPointerMode.None;
			_restoreChatFocusAfterPointer = false;
			_dragCamera = null;
			if ((Object)(object)_root != (Object)null)
			{
				_root.SetActive(false);
				Object.Destroy((Object)(object)_root);
				_root = null;
			}
			_rootRect = null;
			_headerRect = null;
			_headerClanName = null;
			_headerDragSurface = null;
			_collapseButtonRect = null;
			_collapseIcon = null;
			_rows = Array.Empty<HudRowView>();
			_nextRequestTime = 0f;
			_displayedClanId = "";
			_lastScreenWidth = 0;
			_lastScreenHeight = 0;
			_lastSafeArea = default(Rect);
			_lastHudScale = Vector2.zero;
			_trackedHudParent = null;
			_lastHudParentActive = false;
			_lastHudParentSize = Vector2.zero;
			_uiRaycastEventSystem = null;
			_uiRaycastPointerData = null;
			UiRaycastResults.Clear();
		}

		public static void Tick()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			Transform hudParent = GetHudParent();
			if ((Object)(object)hudParent == (Object)null)
			{
				CancelPointerInteraction(saveDrag: false, restoreChatFocus: false);
				if ((Object)(object)_root != (Object)null)
				{
					_root.SetActive(false);
				}
				_trackedHudParent = null;
				_lastHudParentActive = false;
				_lastHudParentSize = Vector2.zero;
				return;
			}
			if ((Object)(object)_root == (Object)null || (Object)(object)_root.transform.parent != (Object)(object)hudParent)
			{
				Rebuild();
				if ((Object)(object)_root == (Object)null || (Object)(object)_root.transform.parent != (Object)(object)hudParent)
				{
					return;
				}
			}
			if (HudParentEnvironmentChanged(hudParent))
			{
				_nextRequestTime = 0f;
				Refresh();
				if (((Component)hudParent).gameObject.activeInHierarchy)
				{
					ApplyConfiguredPosition();
				}
			}
			if (ScreenEnvironmentChanged() && _pointerMode != HudPointerMode.Drag)
			{
				ApplyConfiguredPosition();
			}
			ClanClientSnapshot currentSnapshot = ClanRpc.CurrentSnapshot;
			bool num = ReconcileVisibility();
			UpdateHeaderRaycastState();
			HandleHudPointerInput();
			if (!num)
			{
				_nextRequestTime = 0f;
				return;
			}
			if (IsPlayerListCollapsed())
			{
				_nextRequestTime = 0f;
				return;
			}
			AnimateSlowHealth();
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!(realtimeSinceStartup < _nextRequestTime))
			{
				_nextRequestTime = realtimeSinceStartup + 0.5f;
				ClanRpc.RequestHudSnapshot(currentSnapshot.ClanId);
			}
		}

		private static bool ShouldShow(ClanClientSnapshot snapshot)
		{
			return ShouldShow(snapshot, GetHudParent());
		}

		private static bool ShouldShow(ClanClientSnapshot snapshot, Transform? hudParent)
		{
			if ((Object)(object)ZNet.instance != (Object)null && (Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)hudParent != (Object)null && ((Component)hudParent).gameObject.activeInHierarchy && ClanPlugin.ShowClanHud.Value.IsOn())
			{
				return snapshot.HasClan;
			}
			return false;
		}

		private static bool ReconcileVisibility()
		{
			ClanClientSnapshot currentSnapshot = ClanRpc.CurrentSnapshot;
			Transform hudParent = GetHudParent();
			bool flag = ShouldShow(currentSnapshot, hudParent);
			if ((Object)(object)_root == (Object)null)
			{
				return flag;
			}
			bool num = _root.activeSelf != flag;
			bool flag2 = flag && !StringComparer.Ordinal.Equals(_displayedClanId, currentSnapshot.ClanId);
			if (!num && !flag2)
			{
				return flag;
			}
			_nextRequestTime = 0f;
			Refresh();
			if (flag)
			{
				ApplyConfiguredPosition();
			}
			return flag;
		}

		internal static bool CapturesChatPointer(Vector2 pointerPosition)
		{
			//IL_0033: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			if (_pointerMode != HudPointerMode.None)
			{
				return true;
			}
			if (!HasReleasedCursor() || !((Object)(object)_headerRect != (Object)null) || !((Component)_headerRect).gameObject.activeInHierarchy || !RectTransformUtility.RectangleContainsScreenPoint(_headerRect, pointerPosition, ClanUiFactory.GetCanvasCamera((Component?)(object)_headerRect)))
			{
				return false;
			}
			if (!InventoryGui.IsVisible())
			{
				return IsHudTopmostAtPointer(pointerPosition);
			}
			return !IsPointerBlockedByVisibleInventoryPanel(pointerPosition);
		}

		private static void Refresh()
		{
			if ((Object)(object)_root == (Object)null)
			{
				return;
			}
			ClanClientSnapshot currentSnapshot = ClanRpc.CurrentSnapshot;
			bool flag = ShouldShow(currentSnapshot);
			_root.SetActive(flag);
			_displayedClanId = (flag ? currentSnapshot.ClanId : "");
			if (!flag)
			{
				HideRows();
				LayoutVisibleRows(0);
				return;
			}
			if ((Object)(object)_headerClanName != (Object)null)
			{
				_headerClanName.text = ClanLocalization.Format("clan_hud_header", ClanUiFactory.CleanSingleLine(currentSnapshot.ClanName));
			}
			if (IsPlayerListCollapsed())
			{
				HideRows();
				LayoutVisibleRows(0);
				return;
			}
			ClanHudSnapshot currentHudSnapshot = ClanRpc.CurrentHudSnapshot;
			if (!StringComparer.Ordinal.Equals(currentHudSnapshot.ClanId, currentSnapshot.ClanId))
			{
				HideRows();
				LayoutVisibleRows(0);
				return;
			}
			int num = 0;
			foreach (ClanHudPlayerSummary player2 in currentHudSnapshot.Players)
			{
				if (num == _rows.Length)
				{
					break;
				}
				if (TryFindOnlineRosterPlayer(currentSnapshot, player2.PlayerId, out ClanPlayerSummary player))
				{
					UpdateRow(_rows[num], player2, player);
					num++;
				}
			}
			for (int i = num; i < _rows.Length; i++)
			{
				_rows[i].Root.SetActive(false);
			}
			LayoutVisibleRows(num);
		}

		private static void OnLanguageChanged()
		{
			Refresh();
		}

		private static void HideRows()
		{
			HudRowView[] rows = _rows;
			for (int i = 0; i < rows.Length; i++)
			{
				rows[i].Root.SetActive(false);
			}
		}

		private static bool TryFindOnlineRosterPlayer(ClanClientSnapshot snapshot, string playerId, out ClanPlayerSummary player)
		{
			foreach (ClanPlayerSummary item in snapshot.Roster)
			{
				if (item.IsOnline && StringComparer.Ordinal.Equals(item.Id, playerId))
				{
					player = item;
					return true;
				}
			}
			player = null;
			return false;
		}

		private static void UpdateRow(HudRowView row, ClanHudPlayerSummary player, ClanPlayerSummary rosterPlayer)
		{
			bool initialize = !row.Root.activeSelf || !StringComparer.Ordinal.Equals(row.PlayerId, player.PlayerId);
			row.Root.SetActive(true);
			row.PlayerId = player.PlayerId;
			row.Label.text = ClanLocalization.Format("clan_hud_player", ClanLocalization.Role(rosterPlayer.Role), ClanUiFactory.CleanSingleLine(rosterPlayer.Name));
			if (!player.HasHealth || !IsFinite(player.CurrentHealth) || !IsFinite(player.MaxHealth) || !(player.MaxHealth > 0f))
			{
				row.BarWidth = 100f;
				SetHealthRatio(row, 0f, initialize: true);
				row.Health.text = "— / —";
			}
			else
			{
				float maxHealth = player.MaxHealth;
				float num = Mathf.Clamp(player.CurrentHealth, 0f, maxHealth);
				row.BarWidth = GetLogScaledBarWidth(maxHealth);
				SetHealthRatio(row, Mathf.Clamp01(num / maxHealth), initialize);
				row.Health.text = FormatHealth(num) + "/" + FormatHealth(maxHealth);
			}
		}

		private static float GetLogScaledBarWidth(float maximumHealth)
		{
			float num = Mathf.Log(11f);
			float num2 = ((num <= 0f) ? 0f : (Mathf.Log(1f + maximumHealth / 100f) / num));
			return Mathf.Ceil(Mathf.Lerp(100f, 220f, Mathf.Clamp01(num2)));
		}

		private static void SetHealthRatio(HudRowView row, float ratio, bool initialize)
		{
			ratio = Mathf.Clamp01(ratio);
			float fastRatio = row.FastRatio;
			row.FastRatio = ratio;
			SetFill(row.FastFill, ratio);
			if (initialize)
			{
				row.SlowRatio = ratio;
				row.SlowTargetRatio = ratio;
				row.SlowDelayUntil = 0f;
				SetFill(row.SlowFill, ratio);
				return;
			}
			if (ratio > fastRatio + 0.0001f)
			{
				row.SlowRatio = ratio;
				row.SlowTargetRatio = ratio;
				row.SlowDelayUntil = 0f;
				SetFill(row.SlowFill, ratio);
				return;
			}
			if (ratio < fastRatio - 0.0001f)
			{
				row.SlowRatio = Mathf.Max(row.SlowRatio, fastRatio);
				row.SlowDelayUntil = Time.unscaledTime + 0.35f;
			}
			row.SlowTargetRatio = ratio;
		}

		private static void AnimateSlowHealth()
		{
			float unscaledTime = Time.unscaledTime;
			float num = 0.6f * Time.unscaledDeltaTime;
			HudRowView[] rows = _rows;
			foreach (HudRowView hudRowView in rows)
			{
				if (hudRowView.Root.activeSelf && !(unscaledTime < hudRowView.SlowDelayUntil) && !(hudRowView.SlowRatio <= hudRowView.SlowTargetRatio))
				{
					hudRowView.SlowRatio = Mathf.MoveTowards(hudRowView.SlowRatio, hudRowView.SlowTargetRatio, num);
					SetFill(hudRowView.SlowFill, hudRowView.SlowRatio);
				}
			}
		}

		private static void SetFill(RectTransform fill, float ratio)
		{
			//IL_0001: 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_0022: 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)
			fill.anchorMin = Vector2.zero;
			fill.anchorMax = new Vector2(Mathf.Clamp01(ratio), 1f);
			fill.offsetMin = Vector2.zero;
			fill.offsetMax = Vector2.zero;
		}

		private static string FormatHealth(float health)
		{
			return Mathf.Ceil(health).ToString("0", CultureInfo.InvariantCulture);
		}

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

		private static void Rebuild()
		{
			Rebuild(GetHudParent());
		}

		private static void Rebuild(Transform? hudParent)
		{
			//IL_00a2: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			if (!GUIManager.IsHeadless() && !((Object)(object)hudParent == (Object)null))
			{
				CancelPointerInteraction(saveDrag: false, restoreChatFocus: false);
				if ((Object)(object)_root != (Object)null)
				{
					_root.SetActive(false);
					Object.Destroy((Object)(object)_root);
				}
				Sprite healthSprite = null;
				Material healthMaterial = null;
				try
				{
					healthSprite = GUIManager.Instance.GetSprite("bar_gradient");
				}
				catch (Exception)
				{
				}
				try
				{
					healthMaterial = Cache.GetPrefab<Material>("lithud");
				}
				catch (Exception)
				{
				}
				_root = ClanUiFactory.CreateObject("ClanMemberHud", hudParent);
				_root.SetActive(false);
				_rootRect = _root.GetComponent<RectTransform>();
				_rootRect.anchorMin = new Vector2(0f, 1f);
				_rootRect.anchorMax = new Vector2(0f, 1f);
				_rootRect.pivot = new Vector2(0f, 1f);
				_rootRect.anchoredPosition = new Vector2(18f, -220f);
				_rootRect.sizeDelta = new Vector2(0f, 42f);
				CreateHeader(_root.transform);
				_rows = new HudRowView[10];
				for (int i = 0; i < _rows.Length; i++)
				{
					_rows[i] = CreateMemberRow(_root.transform, i, healthSprite, healthMaterial);
					_rows[i].Root.SetActive(false);
				}
				_lastScreenWidth = 0;
				_lastScreenHeight = 0;
				_lastSafeArea = default(Rect);
				_lastHudScale = Vector2.zero;
				_displayedClanId = "";
				_nextRequestTime = 0f;
				_trackedHudParent = hudParent;
				_lastHudParentActive = false;
				_lastHudParentSize = Vector2.zero;
				Refresh();
				ApplyConfiguredPosition();
			}
		}

		private static void CreateHeader(Transform parent)
		{
			//IL_003a: 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_0139: 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_0163: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = ClanUiFactory.CreateObject("HudHeader", parent, typeof(Image));
			_headerRect = val.GetComponent<RectTransform>();
			_headerDragSurface = val.GetComponent<Image>();
			((Graphic)_headerDragSurface).color = Color.clear;
			((Graphic)_headerDragSurface).raycastTarget = HasReleasedCursor();
			_headerClanName = CreateText(val.transform, ClanLocalization.Text("clan_hud_title"), 24, (TextAnchor)3, HeaderNameColor, bold: true);
			_headerClanName.resizeTextForBestFit = true;
			_headerClanName.resizeTextMinSize = 18;
			_headerClanName.resizeTextMaxSize = 24;
			SetTopLeftRect(((Graphic)_headerClanName).rectTransform, 0f, 0f, 0f, 42f);
			AddTextOutline(_headerClanName);
			GameObject val2 = ClanUiFactory.CreateObject("HudPlayerListToggle", val.transform);
			_collapseButtonRect = val2.GetComponent<RectTransform>();
			SetTopLeftRect(_collapseButtonRect, 0f, 8f, 26f, 26f);
			GameObject obj = ClanUiFactory.CreateObject("Icon", val2.transform, typeof(Image));
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = Vector2.zero;
			component.sizeDelta = new Vector2(14f, 14f);
			_collapseIcon = obj.GetComponent<Image>();
			_collapseIcon.sprite = ClanUiFeedback.GetIcon(ClanActionIcon.Collapse);
			_collapseIcon.preserveAspect = true;
			((Graphic)_collapseIcon).raycastTarget = false;
			((Graphic)_collapseIcon).color = HeaderToggleColor;
			RefreshCollapseButton();
		}

		private static HudRowView CreateMemberRow(Transform parent, int index, Sprite? healthSprite, Material? healthMaterial)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: 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_0184: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = ClanUiFactory.CreateObject($"HudMemberRow{index}", parent);
			RectTransform component = val.GetComponent<RectTransform>();
			Text val2 = CreateText(val.transform, "", 13, (TextAnchor)3, RowTextColor, bold: true);
			val2.resizeTextForBestFit = true;
			val2.resizeTextMinSize = 10;
			val2.resizeTextMaxSize = 13;
			AddTextOutline(val2);
			GameObject val3 = ClanUiFactory.CreateObject("HealthBar", val.transform, typeof(Image));
			RectTransform component2 = val3.GetComponent<RectTransform>();
			Image component3 = val3.GetComponent<Image>();
			((Graphic)component3).color = HealthBackgroundColor;
			((Graphic)component3).raycastTarget = false;
			RectTransform component4 = ClanUiFactory.CreateObject("FillArea", val3.transform).GetComponent<RectTransform>();
			Stretch(component4, 2f, 2f, 2f, 2f);
			GameObject obj = ClanUiFactory.CreateObject("HealthSlow", (Transform)(object)component4, typeof(Image));
			Image component5 = obj.GetComponent<Image>();
			((Graphic)component5).color = HealthSlowColor;
			((Graphic)component5).raycastTarget = false;
			ApplyVanillaHealthStyle(component5, healthSprite, healthMaterial);
			RectTransform component6 = obj.GetComponent<RectTransform>();
			SetFill(component6, 0f);
			GameObject obj2 = ClanUiFactory.CreateObject("HealthFast", (Transform)(object)component4, typeof(Image));
			Image component7 = obj2.GetComponent<Image>();
			((Graphic)component7).color = HealthFastColor;
			((Graphic)component7).raycastTarget = false;
			ApplyVanillaHealthStyle(component7, healthSprite, healthMaterial);
			RectTransform component8 = obj2.GetComponent<RectTransform>();
			SetFill(component8, 0f);
			Text val4 = CreateText(val3.transform, "— / —", 12, (TextAnchor)4, Color.white, bold: true);
			val4.resizeTextForBestFit = true;
			val4.resizeTextMinSize = 9;
			val4.resizeTextMaxSize = 12;
			Stretch(((Graphic)val4).rectTransform, 3f, 3f, 0f, 0f);
			AddTextOutline(val4);
			return new HudRowView
			{
				Root = val,
				Rect = component,
				Label = val2,
				Bar = component2,
				SlowFill = component6,
				FastFill = component8,
				Health = val4
			};
		}

		private static void ApplyVanillaHealthStyle(Image image, Sprite? sprite, Material? material)
		{
			if ((Object)(object)sprite != (Object)null)
			{
				image.sprite = sprite;
				image.type = (Type)2;
				image.pixelsPerUnitMultiplier = 2f;
			}
			if ((Object)(object)material != (Object)null)
			{
				((Graphic)image).material = material;
			}
		}

		private static void LayoutVisibleRows(int visibleCount)
		{
			//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_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_rootRect == (Object)null) && !((Object)(object)_headerRect == (Object)null))
			{
				visibleCount = Mathf.Clamp(visibleCount, 0, _rows.Length);
				float num = 0f;
				for (int i = 0; i < visibleCount; i++)
				{
					HudRowView hudRowView = _rows[i];
					num = Mathf.Max(num, Mathf.Min(190f, Mathf.Ceil(MeasureNaturalWidth(hudRowView.Label))));
				}
				float num2 = Mathf.Max(0f, 410f);
				float num3 = (((Object)(object)_headerClanName == (Object)null) ? 0f : Mathf.Clamp(Mathf.Ceil(MeasureNaturalWidth(_headerClanName)), 0f, num2));
				float num4 = num3 + 7f + 26f + 7f;
				float num5 = num4;
				for (int j = 0; j < visibleCount; j++)
				{
					float num6 = num + 7f + _rows[j].BarWidth + 7f;
					num5 = Mathf.Max(num5, num6);
				}
				num5 = Mathf.Min(num5, 450f);
				float num7 = ((visibleCount == 0) ? 0f : (5f + (float)visibleCount * 26f + (float)(visibleCount - 1) * 3f));
				float num8 = 42f + num7;
				Rect rect = _rootRect.rect;
				int num9;
				if (!(Mathf.Abs(((Rect)(ref rect)).width - num5) > 0.1f))
				{
					rect = _rootRect.rect;
					num9 = ((Mathf.Abs(((Rect)(ref rect)).height - num8) > 0.1f) ? 1 : 0);
				}
				else
				{
					num9 = 1;
				}
				bool flag = (byte)num9 != 0;
				_rootRect.sizeDelta = new Vector2(num5, num8);
				SetTopLeftRect(_headerRect, 0f, 0f, num4, 42f);
				if ((Object)(object)_headerClanName != (Object)null)
				{
					SetTopLeftRect(((Graphic)_headerClanName).rectTransform, 0f, 0f, num3, 42f);
				}
				if ((Object)(object)_collapseButtonRect != (Object)null)
				{
					SetTopLeftRect(_collapseButtonRect, num3 + 7f, 8f, 26f, 26f);
				}
				float num10 = 47f;
				for (int k = 0; k < visibleCount; k++)
				{
					HudRowView hudRowView2 = _rows[k];
					float top = num10 + (float)k * 29f;
					float width = num + 7f + hudRowView2.BarWidth + 7f;
					SetTopLeftRect(hudRowView2.Rect, 0f, top, width, 26f);
					SetTopLeftRect(((Graphic)hudRowView2.Label).rectTransform, 0f, 0f, num, 26f);
					SetTopLeftRect(hudRowView2.Bar, num + 7f, 3f, hudRowView2.BarWidth, 20f);
				}
				if (flag && _pointerMode != HudPointerMode.Drag)
				{
					ApplyConfiguredPosition();
				}
			}
		}

		private static void SetTopLeftRect(RectTransform rect, float left, float top, float width, float height)
		{
			//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_0043: 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)
			rect.anchorMin = new Vector2(0f, 1f);
			rect.anchorMax = new Vector2(0f, 1f);
			rect.pivot = new Vector2(0f, 1f);
			rect.anchoredPosition = new Vector2(left, 0f - top);
			rect.sizeDelta = new Vector2(width, height);
		}

		private static float MeasureNaturalWidth(Text text)
		{
			//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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			TextGenerationSettings generationSettings = text.GetGenerationSettings(Vector2.zero);
			generationSettings.resizeTextForBestFit = false;
			generationSettings.horizontalOverflow = (HorizontalWrapMode)1;
			return text.cachedTextGeneratorForLayout.GetPreferredWidth(text.text, generationSettings) / Mathf.Max(0.0001f, text.pixelsPerUnit);
		}

		private static void Stretch(RectTransform rect, float left, float right, float bottom, float top)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = new Vector2(left, bottom);
			rect.offsetMax = new Vector2(0f - right, 0f - top);
		}

		private static void OnSnapshotChanged(ClanClientSnapshot snapshot)
		{
			if (!StringComparer.Ordinal.Equals(_displayedClanId, snapshot.ClanId))
			{
				_nextRequestTime = 0f;
			}
			Refresh();
			if (ShouldShow(snapshot))
			{
				ApplyConfiguredPosition();
			}
		}

		private static void OnHudSnapshotChanged(ClanHudSnapshot snapshot)
		{
			Refresh();
		}

		private static void OnHudPositionChanged(object sender, EventArgs args)
		{
			if (_pointerMode != HudPointerMode.Drag && !_isWritingPosition)
			{
				ApplyConfiguredPosition();
			}
		}

		private static void OnPlayerListCollapsedChanged(object sender, EventArgs args)
		{
			_nextRequestTime = 0f;
			RefreshCollapseButton();
			Refresh();
		}

		private static void OnShowHudChanged(object sender, EventArgs args)
		{
			_nextRequestTime = 0f;
			Refresh();
			ApplyConfiguredPosition();
		}

		private static bool IsPlayerListCollapsed()
		{
			return ClanPlugin.ClanHudPlayerListCollapsed.Value.IsOn();
		}

		private static void TogglePlayerListCollapsed()
		{
			ClanPlugin.ClanHudPlayerListCollapsed.Value = ((!IsPlayerListCollapsed()) ? ClanPlugin.Toggle.On : ClanPlugin.Toggle.Off);
		}

		private static void RefreshCollapseButton()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			bool flag = IsPlayerListCollapsed();
			if ((Object)(object)_collapseIcon != (Object)null)
			{
				_collapseIcon.sprite = ClanUiFeedback.GetIcon(flag ? ClanActionIcon.Expand : ClanActionIcon.Collapse);
				((Graphic)_collapseIcon).color = HeaderToggleColor;
			}
		}

		private static bool HudParentEnvironmentChanged(Transform hudParent)
		{
			//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_0021: 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_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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			bool flag = (Object)(object)_trackedHudParent != (Object)(object)hudParent;
			bool activeInHierarchy = ((Component)hudParent).gameObject.activeInHierarchy;
			RectTransform val = (RectTransform)(object)((hudParent is RectTransform) ? hudParent : null);
			Vector2 val2;
			if (val == null)
			{
				val2 = Vector2.zero;
			}
			else
			{
				Rect rect = val.rect;
				val2 = ((Rect)(ref rect)).size;
			}
			Vector2 val3 = val2;
			bool flag2 = activeInHierarchy && (flag || !_lastHudParentActive);
			int num;
			if (activeInHierarchy)
			{
				if (!flag)
				{
					Vector2 val4 = val3 - _lastHudParentSize;
					num = ((((Vector2)(ref val4)).sqrMagnitude > 0.25f) ? 1 : 0);
				}
				else
				{
					num = 1;
				}
			}
			else
			{
				num = 0;
			}
			bool flag3 = (byte)num != 0;
			_trackedHudParent = hudParent;
			_lastHudParentActive = activeInHierarchy;
			_lastHudParentSize = val3;
			return flag2 || flag3;
		}

		private static bool ScreenEnvironmentChanged()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_0024: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			Rect safeArea = GetSafeArea();
			Vector3 val = (((Object)(object)_rootRect == (Object)null) ? Vector3.one : ((Transform)_rootRect).lossyScale);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(Mathf.Abs(val.x), Mathf.Abs(val.y));
			int result;
			if (_lastScreenWidth == Screen.width && _lastScreenHeight == Screen.height && ClanUiFactory.RectApproximately(_lastSafeArea, safeArea))
			{
				Vector2 val3 = _lastHudScale - val2;
				result = ((((Vector2)(ref val3)).sqrMagnitude > 1E-06f) ? 1 : 0);
			}
			else
			{
				result = 1;
			}
			_lastScreenWidth = Screen.width;
			_lastScreenHeight = Screen.height;
			_lastSafeArea = safeArea;
			_lastHudScale = val2;
			return (byte)result != 0;
		}

		private static void ApplyConfiguredPosition()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_rootRect == (Object)null))
			{
				Transform parent = ((Transform)_rootRect).parent;
				RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				if (val != null)
				{
					Vector2 val2 = SanitizeNormalizedPosition(ClanPlugin.ClanHudPosition.Value);
					Canvas.ForceUpdateCanvases();
					Camera canvasCamera = ClanUiFactory.GetCanvasCamera((Component?)(object)_rootRect);
					Rect safeArea = GetSafeArea();
					Vector2 screenPosition = default(Vector2);
					((Vector2)(ref screenPosition))..ctor(((Rect)(ref safeArea)).xMin + val2.x * ((Rect)(ref safeArea)).width, ((Rect)(ref safeArea)).yMax - val2.y * ((Rect)(ref safeArea)).height);
					SetRootPivotScreenPosition(val, screenPosition, canvasCamera);
					ClampToSafeArea(val, safeArea, canvasCamera);
				}
			}
		}

		private static Vector2 SanitizeNormalizedPosition(Vector2 value)
		{
			//IL_0000: 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_000d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (!IsFinite(value.x) || !IsFinite(value.y))
			{
				return DefaultNormalizedPosition;
			}
			return new Vector2(Mathf.Clamp01(value.x), Mathf.Clamp01(value.y));
		}

		private static bool CanStartDrag()
		{
			if ((Object)(object)_root != (Object)null && _root.activeInHierarchy)
			{
				if (_pointerMode != HudPointerMode.HeaderPending)
				{
					return _pointerMode == HudPointerMode.Drag;
				}
				return true;
			}
			return false;
		}

		private static bool HasReleasedCursor()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			if (Cursor.visible)
			{
				return (int)Cursor.lockState != 1;
			}
			return false;
		}

		private static void UpdateHeaderRaycastState()
		{
			bool raycastTarget = HasReleasedCursor() || _pointerMode != HudPointerMode.None;
			if ((Object)(object)_headerDragSurface != (Object)null)
			{
				((Graphic)_headerDragSurface).raycastTarget = raycastTarget;
			}
		}

		private static void HandleHudPointerInput()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: 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_0149: 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_01d0: 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_01da: 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_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: 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_01af: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_root == (Object)null || !_root.activeInHierarchy || (Object)(object)_headerRect == (Object)null || !((Component)_headerRect).gameObject.activeInHierarchy)
			{
				CancelPointerInteraction(saveDrag: false, restoreChatFocus: false);
				return;
			}
			Vector2 val = Vector2.op_Implicit(Input.mousePosition);
			Camera canvasCamera = ClanUiFactory.GetCanvasCamera((Component?)(object)_headerRect);
			bool flag = RectTransformUtility.RectangleContainsScreenPoint(_headerRect, val, canvasCamera);
			bool flag2 = (Object)(object)_collapseButtonRect != (Object)null && ((Component)_collapseButtonRect).gameObject.activeInHierarchy && RectTransformUtility.RectangleContainsScreenPoint(_collapseButtonRect, val, ClanUiFactory.GetCanvasCamera((Component?)(object)_collapseButtonRect));
			bool flag3 = InventoryGui.IsVisible();
			bool flag4 = HasReleasedCursor() && (!flag3 || !IsPointerBlockedByVisibleInventoryPanel(val)) && (flag3 || IsHudTopmostAtPointer(val));
			bool flag5 = (Object)(object)_headerClanName != (Object)null && RectTransformUtility.RectangleContainsScreenPoint(((Graphic)_headerClanName).rectTransform, val, ClanUiFactory.GetCanvasCamera((Component?)(object)((Graphic)_headerClanName).rectTransform));
			if ((Object)(object)_headerClanName != (Object)null)
			{
				((Graphic)_headerClanName).color = ((flag4 && flag5) ? HeaderNameHoverColor : HeaderNameColor);
			}
			if ((Object)(object)_collapseIcon != (Object)null)
			{
				((Graphic)_collapseIcon).color = ((_pointerMode == HudPointerMode.Collapse) ? HeaderTogglePressedColor : ((_pointerMode == HudPointerMode.None && flag4 && flag2) ? HeaderToggleHoverColor : HeaderToggleColor));
			}
			if (_pointerMode == HudPointerMode.None)
			{
				if (Input.GetMouseButtonDown(0) && flag4 && flag)
				{
					_pointerMode = (flag2 ? HudPointerMode.Collapse : HudPointerMode.HeaderPending);
					_restoreChatFocusAfterPointer = !flag3 && ClanVanillaChatDock.HasFocusedChatInputForHud();
					_headerPressPosition = val;
					if ((Object)(object)_collapseIcon != (Object)null && flag2)
					{
						((Graphic)_collapseIcon).color = HeaderTogglePressedColor;
					}
					UpdateHeaderRaycastState();
				}
				return;
			}
			if (Input.GetMouseButton(0))
			{
				if (_pointerMode == HudPointerMode.HeaderPending)
				{
					Vector2 val2 = val - _headerPressPosition;
					if (((Vector2)(ref val2)).sqrMagnitude >= 25f && BeginDrag(val, canvasCamera))
					{
						_pointerMode = HudPointerMode.Drag;
					}
				}
				if (_pointerMode == HudPointerMode.Drag)
				{
					Drag(val);
				}
				return;
			}
			bool num = _pointerMode == HudPointerMode.Collapse && Input.GetMouseButtonUp(0) && flag2 && (!InventoryGui.IsVisible() || !IsPointerBlockedByVisibleInventoryPanel(val));
			bool saveDrag = _pointerMode == HudPointerMode.Drag;
			bool restoreChatFocusAfterPointer = _restoreChatFocusAfterPointer;
			CancelPointerInteraction(saveDrag, restoreChatFocus: false);
			if (num)
			{
				TogglePlayerListCollapsed();
			}
			if (restoreChatFocusAfterPointer && !InventoryGui.IsVisible())
			{
				ClanVanillaChatDock.RestoreChatInputAfterHudInteraction();
			}
		}

		private static void CancelPointerInteraction(bool saveDrag, bool restoreChatFocus)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			bool num = restoreChatFocus && _restoreChatFocusAfterPointer;
			if (_pointerMode == HudPointerMode.Drag)
			{
				EndDrag(saveDrag);
			}
			_pointerMode = HudPointerMode.None;
			_restoreChatFocusAfterPointer = false;
			_dragCamera = null;
			if ((Object)(object)_collapseIcon != (Object)null)
			{
				((Graphic)_collapseIcon).color = HeaderToggleColor;
			}
			UpdateHeaderRaycastState();
			if (num && !InventoryGui.IsVisible())
			{
				ClanVanillaChatDock.RestoreChatInputAfterHudInteraction();
			}
		}

		private static bool IsPointerBlockedByVisibleInventoryPanel(Vector2 pointerPosition)
		{
			//IL_0020: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_0074: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			if (!InventoryGui.IsVisible())
			{
				return false;
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			if (!ContainsPointerInActivePanel((Component?)(object)instance.m_player, pointerPosition) && !ContainsPointerInActivePanel((Component?)(object)instance.m_crafting, pointerPosition) && !ContainsPointerInActivePanel((Component?)(object)instance.m_info, pointerPosition) && !ContainsPointerInActivePanel((Component?)(object)instance.m_container, pointerPosition) && !ContainsPointerInActivePanel((Component?)(object)instance.m_variantDialog, pointerPosition) && !ContainsPointerInActivePanel((Component?)(object)instance.m_skillsDialog, pointerPosition) && !ContainsPointerInActivePanel((Component?)(object)instance.m_textsDialog, pointerPosition) && !ContainsPointerInActivePanel((Component?)(object)instance.m_splitPanel, pointerPosition))
			{
				return ContainsPointerInActivePanel(instance.m_trophiesPanel, pointerPosition);
			}
			return true;
		}

		private static bool ContainsPointerInActivePanel(Component? panel, Vector2 pointerPosition)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)panel == (Object)null)
			{
				return false;
			}
			return ContainsPointerInActivePanel(panel.gameObject, pointerPosition);
		}

		private static bool ContainsPointerInActivePanel(GameObject? panel, Vector2 pointerPosition)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)panel == (Object)null) && panel.activeInHierarchy)
			{
				Transform transform = panel.transform;
				RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (val != null)
				{
					return RectTransformUtility.RectangleContainsScreenPoint(val, pointerPosition, ClanUiFactory.GetCanvasCamera((Component?)(object)val));
				}
			}
			return false;
		}

		private static bool IsHudTopmostAtPointer(Vector2 pointerPosition)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_root == (Object)null || !_root.activeInHierarchy)
			{
				return false;
			}
			EventSystem current = EventSystem.current;
			if ((Object)(object)current == (Object)null || !((Behaviour)current).isActiveAndEnabled)
			{
				return false;
			}
			if ((Object)(object)_uiRaycastEventSystem != (Object)(object)current || _uiRaycastPointerData == null)
			{
				_uiRaycastEventSystem = current;
				_uiRaycastPointerData = new PointerEventData(current);
			}
			else
			{
				((AbstractEventData)_uiRaycastPointerData).Reset();
			}
			_uiRaycastPointerData.position = pointerPosition;
			_uiRaycastPointerData.button = (InputButton)0;
			UiRaycastResults.Clear();
			current.RaycastAll(_uiRaycastPointerData, UiRaycastResults);
			bool result = false;
			foreach (RaycastResult uiRaycastResult in UiRaycastResults)
			{
				RaycastResult current2 = uiRaycastResult;
				if (current2.module is GraphicRaycaster && !((Object)(object)((RaycastResult)(ref current2)).gameObject == (Object)null))
				{
					Transform transform = ((RaycastResult)(ref current2)).gameObject.transform;
					result = (Object)(object)transform == (Object)(object)_root.transform || transform.IsChildOf(_root.transform);
					break;
				}
			}
			UiRaycastResults.Clear();
			return result;
		}

		private static bool BeginDrag(Vector2 pointerPosition, Camera? eventCamera)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if (!CanStartDrag() || (Object)(object)_rootRect == (Object)null)
			{
				return false;
			}
			_dragCamera = eventCamera ?? ClanUiFactory.GetCanvasCamera((Component?)(object)_rootRect);
			Vector2 val = RectTransformUtility.WorldToScreenPoint(_dragCamera, ((Transform)_rootRect).position);
			_dragPointerOffset = pointerPosition - val;
			return true;
		}

		private static void Drag(Vector2 pointerPosition)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (_pointerMode == HudPointerMode.Drag && !((Object)(object)_rootRect == (Object)null))
			{
				Transform parent = ((Transform)_rootRect).parent;
				RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				if (val != null)
				{
					Vector2 screenPosition = pointerPosition - _dragPointerOffset;
					SetRootPivotScreenPosition(val, screenPosition, _dragCamera);
					ClampToSafeArea(val, GetSafeArea(), _dragCamera);
				}
			}
		}

		private static void EndDrag(bool save)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (_pointerMode != HudPointerMode.Drag)
			{
				return;
			}
			if ((Object)(object)_rootRect != (Object)null)
			{
				Transform parent = ((Transform)_rootRect).parent;
				RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				if (val != null)
				{
					ClampToSafeArea(val, GetSafeArea(), _dragCamera);
				}
			}
			_dragCamera = null;
			if (save)
			{
				SaveCurrentPosition();
			}
		}

		private static void SaveCurrentPosition()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_rootRect == (Object)null)
			{
				return;
			}
			Canvas.ForceUpdateCanvases();
			Camera canvasCamera = ClanUiFactory.GetCanvasCamera((Component?)(object)_rootRect);
			Rect safeArea = GetSafeArea();
			Rect screenBounds = ClanUiFactory.GetScreenBounds(_rootRect, canvasCamera);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor((((Rect)(ref safeArea)).width <= 0f) ? 0f : ((((Rect)(ref screenBounds)).xMin - ((Rect)(ref safeArea)).xMin) / ((Rect)(ref safeArea)).width), (((Rect)(ref safeArea)).height <= 0f) ? 0f : ((((Rect)(ref safeArea)).yMax - ((Rect)(ref screenBounds)).yMax) / ((Rect)(ref safeArea)).height));
			val = SanitizeNormalizedPosition(val);
			Vector2 val2 = ClanPlugin.ClanHudPosition.Value - val;
			if (((Vector2)(ref val2)).sqrMagnitude <= 1E-06f)
			{
				return;
			}
			_isWritingPosition = true;
			try
			{
				ClanPlugin.ClanHudPosition.Value = val;
			}
			finally
			{
				_isWritingPosition = false;
			}
		}

		private static void ClampToSafeArea(RectTransform parentRect, Rect safeArea, Camera? camera)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: 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_0121: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_rootRect == (Object)null))
			{
				Rect screenBounds = ClanUiFactory.GetScreenBounds(_rootRect, camera);
				float num = ((((Rect)(ref screenBounds)).width > ((Rect)(ref safeArea)).width) ? (((Rect)(ref safeArea)).xMin - ((Rect)(ref screenBounds)).xMin) : ((((Rect)(ref screenBounds)).xMin < ((Rect)(ref safeArea)).xMin) ? (((Rect)(ref safeArea)).xMin - ((Rect)(ref screenBounds)).xMin) : ((((Rect)(ref screenBounds)).xMax > ((Rect)(ref safeArea)).xMax) ? (((Rect)(ref safeArea)).xMax - ((Rect)(ref screenBounds)).xMax) : 0f)));
				float num2 = ((((Rect)(ref screenBounds)).height > ((Rect)(ref safeArea)).height) ? (((Rect)(ref safeArea)).yMax - ((Rect)(ref screenBounds)).yMax) : ((((Rect)(ref screenBounds)).yMin < ((Rect)(ref safeArea)).yMin) ? (((Rect)(ref safeArea)).yMin - ((Rect)(ref screenBounds)).yMin) : ((((Rect)(ref screenBounds)).yMax > ((Rect)(ref safeArea)).yMax) ? (((Rect)(ref safeArea)).yMax - ((Rect)(ref screenBounds)).yMax) : 0f)));
				if (!(Mathf.Abs(num) <= 0.01f) || !(Mathf.Abs(num2) <= 0.01f))
				{
					Vector2 val = RectTransformUtility.WorldToScreenPoint(camera, ((Transform)_rootRect).position);
					SetRootPivotScreenPosition(parentRect, val + new Vector2(num, num2), camera);
				}
			}
		}

		private static void SetRootPivotScreenPosition(RectTransform parentRect, Vector2 screenPosition, Camera? camera)
		{
			//IL_000e: 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)
			Vector3 position = default(Vector3);
			if ((Object)(object)_rootRect != (Object)null && RectTransformUtility.ScreenPointToWorldPointInRectangle(parentRect, screenPosition, camera, ref position))
			{
				((Transform)_rootRect).position = position;
			}
		}

		private static Rect GetSafeArea()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			Rect result = Screen.safeArea;
			if (((Rect)(ref result)).width <= 0f || ((Rect)(ref result)).height <= 0f)
			{
				((Rect)(ref result))..ctor(0f, 0f, (float)Screen.width, (float)Screen.height);
			}
			if (((Rect)(ref result)).width > 12f && ((Rect)(ref result)).height > 12f)
			{
				result = Rect.MinMaxRect(((Rect)(ref result)).xMin + 6f, ((Rect)(ref result)).yMin + 6f, ((Rect)(ref result)).xMax - 6f, ((Rect)(ref result)).yMax - 6f);
			}
			return result;
		}

		private static Transform? GetHudParent()
		{
			Hud instance = Hud.instance;
			if (!((Object)(object)instance != (Object)null) || !((Object)(object)instance.m_rootObject != (Object)null))
			{
				return null;
			}
			return instance.m_rootObject.transform;
		}

		private static Text CreateText(Transform parent, string value, int size, TextAnchor anchor, Color color, bool bold)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			Text component = ClanUiFactory.CreateObject("Text", parent, typeof(Text)).GetComponent<Text>();
			component.text = value;
			component.font = (bold ? GUIManager.Instance.AveriaSerifBold : GUIManager.Instance.AveriaSerif);
			component.fontSize = size;
			component.alignment = anchor;
			((Graphic)component).color = color;
			((Graphic)component).raycastTarget = false;
			component.horizontalOverflow = (HorizontalWrapMode)0;
			component.verticalOverflow = (VerticalWrapMode)0;
			return component;
		}

		private static void AddTextOutline(Text text)
		{
			//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)
			Outline obj = ((Component)text).gameObject.AddComponent<Outline>();
			((Shadow)obj).effectColor = new Color(0f, 0f, 0f, 0.78f);
			((Shadow)obj).effectDistance = new Vector2(1f, -1f);
			((Shadow)obj).useGraphicAlpha = true;
		}
	}
	internal static class ClanGifDecoder
	{
		private enum DisposalMethod
		{
			NotSpecified,
			DoNotDispose,
			RestoreToBackground,
			RestoreToPrevious
		}

		internal sealed class Frame
		{
			public int DelayMilliseconds { get; }

			public bool RequiresUserInput { get; }

			public byte[] Rgba32 { get; }

			internal Frame(int delayMilliseconds, bool requiresUserInput, byte[] rgba32)
			{
				DelayMilliseconds = delayMilliseconds;
				RequiresUserInput = requiresUserInput;
				Rgba32 = rgba32;
			}
		}

		internal sealed class Animation
		{
			public int Width { get; }

			public int Height { get; }

			public bool LoopsForever { get; }

			public IReadOnlyList<Frame> Frames { get; }

			internal Animation(int width, int height, bool loopsForever, List<Frame> frames)
			{
				Width = width;
				Height = height;
				LoopsForever = loopsForever;
				Frames = frames.AsReadOnly();
			}
		}

		private sealed class Decoder
		{
			private readonly Reader _reader;

			private readonly int _maximumDimension;

			private readonly int _maximumFrames;

			private readonly long _maximumDecodedPixels;

			private readonly List<Frame> _frames = new List<Frame>();

			private int _width;

			private int _height;

			private int _backgroundColorIndex;

			private long _canvasPixels;

			private byte[]? _globalColorTable;

			private byte[] _canvas = Array.Empty<byte>();

			private bool _canvasInitialized;

			private int? _loopCount;

			private bool _hasPendingControl;

			private GraphicControl _pendingControl;

			private bool _hasPreviousFrame;

			private DisposalMethod _previousDisposal;

			private int _previousLeft;

			private int _previousTop;

			private int _previousWidth;

			private int _previousHeight;

			private bool _previousHadTransparency;

			private int _previousTransparentColorIndex;

			private byte[]? _previousRestoreCanvas;

			public Decoder(byte[] data, int maximumDimension, int maximumFrames, long maximumDecodedPixels)
			{
				_reader = new Reader(data);
				_maximumDimension = maximumDimension;
				_maximumFrames = maximumFrames;
				_maximumDecodedPixels = maximumDecodedPixels;
			}

			public Animation Decode()
			{
				ReadLogicalScreen();
				while (true)
				{
					byte b = _reader.ReadByte("GIF block introducer");
					switch (b)
					{
					case 44:
						ReadImage();
						break;
					case 33:
						ReadExtension();
						break;
					case 59:
						return Finish();
					default:
						throw new InvalidDataException($"GIF contains unsupported block introducer 0x{b:x2}.");
					}
				}
			}

			private void ReadLogicalScreen()
			{
				string x = _reader.ReadAscii(6, "GIF signature");
				if (!StringComparer.Ordinal.Equals(x, "GIF87a") && !StringComparer.Ordinal.Equals(x, "GIF89a"))
				{
					throw new InvalidDataException("File is not a GIF87a or GIF89a image.");
				}
				_width = _reader.ReadUInt16("logical-screen width");
				_height = _reader.ReadUInt16("logical-screen height");
				if (_width <= 0 || _height <= 0 || _width > _maximumDimension || _height > _maximumDimension)
				{
					throw new InvalidDataException($"GIF canvas must be 1-{_maximumDimension}px in each dimension.");
				}
				_canvasPixels = (long)_width * (long)_height;
				if (_canvasPixels > _maximumDecodedPixels || _canvasPixels > 536870911)
				{
					throw new InvalidDataException("GIF canvas exceeds the decoded-pixel limit.");
				}
				byte b = _reader.ReadByte("logical-screen flags");
				_backgroundColorIndex = _reader.ReadByte("background color index");
				_reader.ReadByte("pixel aspect ratio");
				if ((b & 0x80) != 0)
				{
					int num = 1 << (b & 7) + 1;
					_globalColorTable = _reader.ReadColorTable(num, "global color table");
					if (_backgroundColorIndex >= num)
					{
						throw new InvalidDataException("GIF background color index is outside the global color table.");
					}
				}
				_canvas = new byte[(int)_canvasPixels * 4];
			}

			private void ReadExtension()
			{
				byte b = _reader.ReadByte("GIF extension label");
				switch (b)
				{
				case 249:
					ReadGraphicControl();
					break;
				case byte.MaxValue:
					ReadApplicationExtension();
					break;
				case 254:
					_reader.SkipSubBlocks("GIF comment extension");
					break;
				case 1:
					throw new InvalidDataException("GIF Plain Text Extension rendering is not supported.");
				default:
					_reader.SkipSubBlocks($"GIF extension 0x{b:x2}");
					break;
				}
			}

			private void ReadGraphicControl()
			{
				if (_hasPendingControl)
				{
					throw new InvalidDataException("GIF contains multiple graphic controls for one rendering block.");
				}
				if (_reader.ReadByte("graphic-control block size") != 4)
				{
					throw new InvalidDataException("GIF graphic-control block must contain four bytes.");
				}
				byte b = _reader.ReadByte("graphic-control flags");
				if ((b & 0xE0) != 0)
				{
					throw new InvalidDataException("GIF graphic-control block has nonzero reserved bits.");
				}
				int num = (b >> 2) & 7;
				if (num > 3)
				{
					throw new InvalidDataException($"GIF uses unsupported disposal method {num}.");
				}
				int delayCentiseconds = _reader.ReadUInt16("frame delay");
				int transparentColorIndex = _reader.ReadByte("transparent color index");
				if (_reader.ReadByte("graphic-control terminator") != 0)
				{
					throw new InvalidDataException("GIF graphic-control block has an invalid terminator.");
				}
				_pendingControl = new GraphicControl((DisposalMethod)num, (b & 2) != 0, (b & 1) != 0, transparentColorIndex, delayCentiseconds);
				_hasPendingControl = true;
			}

			private void ReadApplicationExtension()
			{
				int num = _reader.ReadByte("application-extension block size");
				if (num != 11)
				{
					throw new InvalidDataException("GIF application identifier must contain eleven bytes.");
				}
				string text = _reader.ReadAscii(num, "application identifier");
				if (!StringComparer.Ordinal.Equals(text, "NETSCAPE2.0") && !StringComparer.Ordinal.Equals(text, "ANIMEXTS1.0"))
				{
					_reader.SkipSubBlocks("GIF application '" + text + "'");
					return;
				}
				if (_reader.ReadByte("loop-extension block size") != 3 || _reader.ReadByte("loop-extension identifier") != 1)
				{
					throw new InvalidDataException("GIF loop extension has an invalid data block.");
				}
				int num2 = _reader.ReadUInt16("loop count");
				if (_reader.ReadByte("loop-extension terminator") != 0)
				{
					throw new InvalidDataException("GIF loop extension has unexpected extra data.");
				}
				if (_loopCount.HasValue && _loopCount.Value != num2)
				{
					throw new InvalidDataException("GIF contains conflicting loop extensions.");
				}
				_loopCount = num2;
			}

			private void ReadImage()
			{
				if (_frames.Count >= _maximumFrames)
				{
					throw new InvalidDataException($"GIF contains more than {_maximumFrames} frames.");
				}
				int num = _frames.Count + 1;
				if (_canvasPixels > _maximumDecodedPixels / num)
				{
					throw new InvalidDataException("GIF frames exceed the cumulative decoded-pixel limit.");
				}
				int num2 = _reader.ReadUInt16("image left");
				int num3 = _reader.ReadUInt16("image top");
				int num4 = _reader.ReadUInt16("image width");
				int num5 = _reader.ReadUInt16("image height");
				if (num4 <= 0 || num5 <= 0 || (long)num2 + (long)num4 > _width || (long)num3 + (long)num5 > _height)
				{
					throw new InvalidDataException("GIF image rectangle is empty or outside the logical screen.");
				}
				byte b = _reader.ReadByte("image flags");
				if ((b & 0x18) != 0)
				{
					throw new InvalidDataException("GIF image descriptor has nonzero reserved bits.");
				}
				bool num6 = (b & 0x80) != 0;
				bool interlaced = (b & 0x40) != 0;
				byte[] array = _globalColorTable;
				if (num6)
				{
					int entryCount = 1 << (b & 7) + 1;
					array = _reader.ReadColorTable(entryCount, "local color table");
				}
				if (array == null)
				{
					throw new InvalidDataException("GIF image does not have an active color table.");
				}
				GraphicControl graphicControl = (_hasPendingControl ? _pendingControl : GraphicControl.Default);
				_hasPendingControl = false;
				_pendingControl = default(GraphicControl);
				int num7 = array.Length / 3;
				if (graphicControl.HasTransparency && graphicControl.TransparentColorIndex >= num7)
				{
					throw new InvalidDataException("GIF transparent color index is outside the active color table.");
				}
				int num8 = _reader.ReadByte("LZW minimum code size");
				if (num8 < 2 || num8 > 8)
				{
					throw new InvalidDataException("GIF LZW minimum code size must be between 2 and 8.");
				}
				long num9 = (long)num4 * (long)num5;
				if (num9 > int.MaxValue)
				{
					throw new InvalidDataException("GIF image rectangle is too large.");
				}
				byte[] indices = DecodeLzw(_reader, num8, (int)num9);
				EnsureCanvasInitialized(graphicControl);
				ApplyPreviousDisposal();
				byte[] previousRestoreCanvas = ((graphicControl.Disposal == DisposalMethod.RestoreToPrevious) ? ((byte[])_canvas.Clone()) : null);
				DrawIndices(indices, array, graphicControl, num2, num3, num4, num5, interlaced);
				byte[] rgba = (byte[])_canvas.Clone();
				_frames.Add(new Frame(graphicControl.DelayCentiseconds * 10, graphicControl.RequiresUserInput, rgba));
				_hasPreviousFrame = true;
				_previousDisposal = graphicControl.Disposal;
				_previousLeft = num2;
				_previousTop = num3;
				_previousWidth = num4;
				_previousHeight = num5;
				_previousHadTransparency = graphicControl.HasTransparency;
				_previousTransparentColorIndex = graphicControl.TransparentColorIndex;
				_previousRestoreCanvas = previousRestoreCanvas;
			}

			private void EnsureCanvasInitialized(GraphicControl firstControl)
			{
				if (!_canvasInitialized)
				{
					if (_globalColorTable != null)
					{
						int num = _backgroundColorIndex * 3;
						byte alpha = (byte)((!firstControl.HasTransparency || firstControl.TransparentColorIndex != _backgroundColorIndex) ? byte.MaxValue : 0);
						FillCanvas(_globalColorTable[num], _globalColorTable[num + 1], _globalColorTable[num + 2], alpha);
					}
					_canvasInitialized = true;
				}
			}

			private void FillCanvas(byte red, byte green, byte blue, byte alpha)
			{
				int num = 0;
				while (num < _canvas.Length)
				{
					_canvas[num++] = red;
					_canvas[num++] = green;
					_canvas[num++] = blue;
					_canvas[num++] = alpha;
				}
			}

			private void ApplyPreviousDisposal()
			{
				if (!_hasPreviousFrame)
				{
					return;
				}
				switch (_previousDisposal)
				{
				case DisposalMethod.RestoreToBackground:
					RestorePreviousRectangleToBackground();
					break;
				case DisposalMethod.RestoreToPrevious:
					if (_previousRestoreCanvas == null || _previousRestoreCanvas.Length != _canvas.Length)
					{
						throw new InvalidDataException("GIF restore-to-previous state is unavailable.");
					}
					Buffer.BlockCopy(_previousRestoreCanvas, 0, _canvas, 0, _canvas.Length);
					break;
				default:
					throw new InvalidDataException("GIF contains an invalid previous-frame disposal method.");
				case DisposalMethod.NotSpecified:
				case DisposalMethod.DoNotDispose:
					break;
				}
				_previousRestoreCanvas = null;
			}

			private void RestorePreviousRectangleToBackground()
			{
				byte b = 0;
				byte b2 = 0;
				byte b3 = 0;
				byte b4 = 0;
				if (_globalColorTable != null)
				{
					int num = _backgroundColorIndex * 3;
					b = _globalColorTable[num];
					b2 = _globalColorTable[num + 1];
					b3 = _globalColorTable[num + 2];
					b4 = (byte)((!_previousHadTransparency || _previousTransparentColorIndex != _backgroundColorIndex) ? byte.MaxValue : 0);
				}
				for (int i = 0; i < _previousHeight; i++)
				{
					int num2 = ((_previousTop + i) * _width + _previousLeft) * 4;
					for (int j = 0; j < _previousWidth; j++)
					{
						_canvas[num2++] = b;
						_canvas[num2++] = b2;
						_canvas[num2++] = b3;
						_canvas[num2++] = b4;
					}
				}
			}

			private void DrawIndices(byte[] indices, byte[] colorTable, GraphicControl control, int left, int top, int width, int height, bool interlaced)
			{
				int sourceOffset = 0;
				if (!interlaced)
				{
					for (int i = 0; i < height; i++)
					{
						DrawRow(indices, ref sourceOffset, colorTable, control, left, top + i, width);
					}
				}
				else
				{
					int[] array = new int[4] { 0, 4, 2, 1 };
					int[] array2 = new int[4] { 8, 8, 4, 2 };
					for (int j = 0; j < array.Length; j++)
					{
						for (int k = array[j]; k < height; k += array2[j])
						{
							DrawRow(indices, ref sourceOffset, colorTable, control, left, top + k, width);
						}
					}
				}
				if (sourceOffset != indices.Length)
				{
					throw new InvalidDataException("GIF interlace pass did not consume the decoded image.");
				}
			}

			private void DrawRow(byte[] indices, ref int sourceOffset, byte[] colorTable, GraphicControl control, int left, int destinationRow, int width)
			{
				int num = (destinationRow * _width + left) * 4;
				for (int i = 0; i < width; i++)
				{
					int num2 = indices[sourceOffset++];
					if (control.HasTransparency && num2 == control.TransparentColorIndex)
					{
						num += 4;
						continue;
					}
					int num3 = num2 * 3;
					if (num3 > colorTable.Length - 3)
					{
						throw new InvalidDataException("GIF pixel references a color outside the active table.");
					}
					_canvas[num++] = colorTable[num3];
					_canvas[num++] = colorTable[num3 + 1];
					_canvas[num++] = colorTable[num3 + 2];
					_canvas[num++] = byte.MaxValue;
				}
			}

			private Animation Finish()
			{
				if (_hasPendingControl)
				{
					throw new InvalidDataException("GIF ends with an unused graphic-control extension.");
				}
				if (_frames.Count == 0)
				{
					throw new InvalidDataException("GIF does not contain an image frame.");
				}
				if (!_reader.IsAtEnd)
				{
					throw new InvalidDataException("GIF contains trailing data after the trailer.");
				}
				return new Animation(_width, _height, _loopCount == 0, _frames);
			}
		}

		private readonly struct GraphicControl
		{
			public static readonly GraphicControl Default = new GraphicControl(DisposalMethod.NotSpecified, requiresUserInput: false, hasTransparency: false, 0, 0);

			public readonly DisposalMethod Disposal;

			public readonly bool RequiresUserInput;

			public readonly bool HasTransparency;

			public readonly int TransparentColorIndex;

			public readonly int DelayCentiseconds;

			public GraphicControl(DisposalMethod disposal, bool requiresUserInput, bool hasTransparency, int transparentColorIndex, int delayCentiseconds)
			{
				Disposal = disposal;
				RequiresUserInput = requiresUserInput;
				HasTransparency = hasTransparency;
				TransparentColorIndex = transparentColorIndex;
				DelayCentiseconds = delayCentiseconds;
			}
		}

		private sealed class Reader
		{
			private readonly byte[] _data;

			public int Position { get; private set; }

			public bool IsAtEnd => Position == _data.Length;

			public Reader(byte[] data)
			{
				_data = data;
			}

			public byte ReadByte(string context)
			{
				Require(1, context);
				return _data[Position++];
			}

			public int ReadUInt16(string context)
			{
				Require(2, context);
				int result = _data[Position] | (_data[Position + 1] << 8);
				Position += 2;
				return result;
			}

			public string ReadAscii(int count, string context)
			{
				Require(count, context);
				string result = Encoding.ASCII.GetString(_data, Position, count);
				Position += count;
				return result;
			}

			public byte[] ReadColorTable(int entryCount, string context)
			{
				int num = entryCount * 3;
				Require(num, context);
				byte[] array = new byte[num];
				Buffer.BlockCopy(_data, Position, array, 0, num);
				Position += num;
				return array;
			}

			public void SkipSubBlocks(string context)
			{
				while (true)
				{
					int num = ReadByte(context + " block size");
					if (num == 0)
					{
						break;
					}
					Require(num, context);
					Position += num;
				}
			}

			private void Require(int count, string context)
			{
				if (count < 0 || Position > _data.Length - count)
				{
					throw new InvalidDataException("GIF ended while reading " + context + ".");
				}
			}
		}

		private sealed class SubBlockBitReader
		{
			private readonly Reader _reader;

			private int _remainingInBlock;

			private uint _bitBuffer;

			private int _bitCount;

			private bool _finished;

			public SubBlockBitReader(Reader reader)
			{
				_reader = reader;
			}

			public int ReadCode(int codeSize)
			{
				if (_finished)
				{
					throw new InvalidDataException("GIF LZW stream was read after its terminator.");
				}
				while (_bitCount < codeSize)
				{
					int num = ReadDataByte();
					if (num < 0)
					{
						throw new InvalidDataException("GIF LZW stream ended before an end code.");
					}
					_bitBuffer |= (uint)(num << _bitCount);
					_bitCount += 8;
				}
				int num2 = (1 << codeSize) - 1;
				int result = (int)_bitBuffer & num2;
				_bitBuffer >>= codeSize;
				_bitCount -= codeSize;
				return result;
			}

			public void FinishAfterEndCode()
			{
				if (_finished)
				{
					throw new InvalidDataException("GIF LZW stream has multiple terminators.");
				}
				while (_remainingInBlock > 0)
				{
					_reader.ReadByte("LZW padding after end code");
					_remainingInBlock--;
				}
				_reader.SkipSubBlocks("LZW padding after end code");
				_finished = true;
			}

			private int ReadDataByte()
			{
				if (_remainingInBlock == 0)
				{
					int num = _reader.ReadByte("LZW sub-block size");
					if (num == 0)
					{
						return -1;
					}
					_remainingInBlock = num;
				}
				_remainingInBlock--;
				return _reader.ReadByte("LZW image data");
			}
		}

		private const int MaximumLzwCodeCount = 4096;

		public static Animation Decode(byte[] data, int maximumBytes, int maximumDimension, int maximumFrames, long maximumDecodedPixels)
		{
			if (data == null)
			{
				throw new InvalidDataException("GIF data is required.");
			}
			if (maximumBytes <= 0 || maximumDimension <= 0 || maximumFrames <= 0 || maximumDecodedPixels <= 0)
			{
				throw new InvalidDataException("GIF decode limits must be positive.");
			}
			if (data.Length > maximumBytes)
			{
				throw new InvalidDataException($"GIF size {data.Length} exceeds the {maximumBytes}-byte limit.");
			}
			return new Decoder(data, maximumDimension, maximumFrames, maximumDecodedPixels).Decode();
		}

		private static byte[] DecodeLzw(Reader reader, int minimumCodeSize, int expectedPixelCount)
		{
			int num = 1 << minimumCodeSize;
			int num2 = num + 1;
			int num3 = num2 + 1;
			int num4 = minimumCodeSize + 1;
			int num5 = -1;
			byte b = 0;
			bool flag = false;
			int[] array = new int[4096];
			byte[] array2 = new byte[4096];
			byte[] array3 = new byte[4097];
			byte[] array4 = new byte[expectedPixelCount];
			int outputOffset = 0;
			for (int i = 0; i < num; i++)
			{
				array2[i] = (byte)i;
			}
			SubBlockBitReader subBlockBitReader = new SubBlockBitReader(reader);
			while (true)
			{
				int num6 = subBlockBitReader.ReadCode(num4);
				if (num6 == num)
				{
					num4 = minimumCodeSize + 1;
					num3 = num2 + 1;
					num5 = -1;
					flag = true;
					continue;
				}
				if (!flag)
				{
					throw new InvalidDataException("GIF LZW stream does not begin with a clear code.");
				}
				if (num6 == num2)
				{
					if (outputOffset != expectedPixelCount)
					{
						throw new InvalidDataException("GIF LZW stream produced an unexpected pixel count.");
					}
					subBlockBitReader.FinishAfterEndCode();
					return array4;
				}
				if (num5 < 0)
				{
					if (num6 < 0 || num6 >= num)
					{
						throw new InvalidDataException("GIF LZW stream has an invalid first code after clear.");
					}
					WriteOutput(array4, ref outputOffset, (byte)num6);
					b = (byte)num6;
					num5 = num6;
					continue;
				}
				int num7 = num6;
				int num8 = 0;
				if (num6 == num3)
				{
					if (num3 >= 4096)
					{
						throw new InvalidDataException("GIF LZW stream references an unavailable code.");
					}
					array3[num8++] = b;
					num6 = num5;
				}
				else if (num6 > num3)
				{
					throw new InvalidDataException("GIF LZW stream references an undefined code.");
				}
				int num9 = 0;
				while (num6 >= num)
				{
					if (num6 < num2 + 1 || num6 >= num3)
					{
						throw new InvalidDataException("GIF LZW dictionary chain is invalid.");
					}
					if (num8 >= array3.Length || ++num9 > 4096)
					{
						throw new InvalidDataException("GIF LZW dictionary chain is cyclic or too deep.");
					}
					array3[num8++] = array2[num6];
					num6 = array[num6];
				}
				if (num6 < 0 || num6 >= num)
				{
					throw new InvalidDataException("GIF LZW dictionary does not end in a literal.");
				}
				b = array2[num6];
				if (num8 >= array3.Length)
				{
					break;
				}
				array3[num8++] = b;
				while (num8 > 0)
				{
					WriteOutput(array4, ref outputOffset, array3[--num8]);
				}
				if (num3 < 4096)
				{
					array[num3] = num5;
					array2[num3] = b;
					num3++;
					if (num3 == 1 << num4 && num4 < 12)
					{
						num4++;
					}
				}
				num5 = num7;
			}
			throw new InvalidDataException("GIF LZW output stack overflowed.");
		}

		private static void WriteOutput(byte[] output, ref int outputOffset, byte value)
		{
			if (outputOffset >= output.Length)
			{
				throw new InvalidDataException("GIF LZW stream produced too many pixels.");
			}
			output[outputOffset++] = value;
		}
	}
	internal static class ClanEmoji
	{
		[HarmonyPatch(typeof(Terminal), "UpdateChat")]
		private static class TerminalUpdateChatPatch
		{
			private static void Prefix(Terminal __instance)
			{
				StopChatOutputAnimationsBeforeRewrite(__instance);
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static class ChatTextEmojiPatch
		{
			[HarmonyPrefix]
			private static void Prefix(TMP_Text __instance, ref string value)
			{
				if ((Object)(object)__instance == (Object)null || !ClanVanillaChatDock.SupportsCurrentChatUi || (Object)(object)Chat.instance == (Object)null)
				{
					return;
				}
				TMP_Text output = (TMP_Text)(object)((Terminal)Chat.instance).m_output;
				if (output != null && __instance == output)
				{
					TMP_SpriteAnimator component = ((Component)__instance).GetComponent<TMP_SpriteAnimator>();
					if (component != null)
					{
						component.StopAllAnimations();
					}
					if (ContainsEmojiMarker(value))
					{
						value = RenderTokens(value);
						int budget = (((Component)__instance).gameObject.activeInHierarchy ? 15 : 0);
						value = ApplyAnimatedSpriteBudget(value, budget);
					}
				}
			}
		}

		private enum MediaRole
		{
			Emoji,
			Emblem
		}

		private enum EmojiFileKind
		{
			Png,
			Gif
		}

		private sealed class ServerFileStamp
		{
			public readonly string FullPath;

			public readonly long Length;

			public readonly long LastWriteTimeUtcTicks;

			private ServerFileStamp(string fullPath, long length, long lastWriteTimeUtcTicks)
			{
				FullPath = fullPath;
				Length = length;
				LastWriteTimeUtcTicks = lastWriteTimeUtcTicks;
			}

			public static ServerFileStamp Capture(FileInfo file)
			{
				file.Refresh();
				if (!file.Exists)
				{
					throw new FileNotFoundException("Media file '" + file.Name + "' disappeared while it was being scanned.", file.FullName);
				}
				return new ServerFileStamp(Path.GetFullPath(file.FullName), file.Length, file.LastWriteTimeUtc.Ticks);
			}

			public bool Matches(ServerFileStamp other)
			{
				if (FilePathComparer.Equals(FullPath, other.FullPath) && Length == other.Length)
				{
					return LastWriteTimeUtcTicks == other.LastWriteTimeUtcTicks;
				}
				return false;
			}
		}

		private sealed class ServerFileCandidate
		{
			public readonly ServerEmojiBlob Blob;

			public readonly ServerFileStamp? Stamp;

			public ServerFileCandidate(ServerEmojiBlob blob, ServerFileStamp? stamp)
			{
				Blob = blob;
				Stamp = stamp;
			}
		}

		private sealed class ManifestRecord
		{
			public readonly MediaRole Role;

			public readonly EmojiFileKind Kind;

			public readonly string Name;

			public readonly int Length;

			public readonly string Hash;

			public string Extension
			{
				get
				{
					if (Kind != EmojiFileKind.Png)
					{
						return ".gif";
					}
					return ".png";
				}
			}

			public ManifestRecord(MediaRole role, EmojiFileKind kind, string name, int length, string hash)
			{
				Role = role;
				Kind = kind;
				Name = name;
				Length = length;
				Hash = hash;
			}
		}

		private sealed class PendingManifestState
		{
			public readonly string Manifest;

			public readonly ZNet? Session;

			public PendingManifestState(string manifest, ZNet? session)
			{
				Manifest = manifest;
				Session = session;
			}
		}

		private enum RuntimeBuildStage
		{
			StaticEmoji,
			AnimatedEmoji,
			Emblems,
			Finalize,
			Completed
		}

		private sealed class BuildState
		{
			public readonly string Manifest;

			public readonly IReadOnlyList<ManifestRecord> Records;

			public readonly ZNet? Session;

			public readonly List<SourceEmoji> Sources = new List<SourceEmoji>();

			public readonly Dictionary<string, SourceEmoji> PreparedSources;

			public readonly CancellationTokenSource Cancellation = new CancellationTokenSource();

			public ManifestRecord? PendingGifRecord;

			public Task<SourceEmoji>? PendingGifTask;

			public RuntimeBuildState? RuntimeBuild;

			public int NextRecordIndex;

			public int Failures;

			public int TotalGifFrames;

			public int GifFrameBudgetSkips;

			public BuildState(string manifest, IReadOnlyList<ManifestRecord> records, ZNet? session)
			{
				Manifest = manifest;
				Records = records;
				Session = session;
				PreparedSources = new Dictionary<string, SourceEmoji>(_preparedSources, StringComparer.Ordinal);
			}

			public void Cancel()
			{
				Cancellation.Cancel();
				RuntimeBuild?.Destroy();
			}
		}

		private sealed class RuntimeBuildState
		{
			public readonly string ManifestHash;

			public readonly IReadOnlyList<SourceEmoji> EmojiSources;

			public readonly IReadOnlyList<SourceEmoji> EmblemSources;

			public readonly IReadOnlyList<SourceEmoji> StillSources;

			public readonly IReadOnlyList<SourceEmoji> AnimatedSources;

			public readonly List<RuntimeSheet> Sheets = new List<RuntimeSheet>();

			public readonly List<RuntimeSheet> EmojiSheets = new List<RuntimeSheet>();

			public readonly Dictionary<SourceEmoji, SourceRuntimeReference> References = new Dictionary<SourceEmoji, SourceRuntimeReference>();

			public RuntimeBuildStage Stage;

			public int NextAnimatedSourceIndex;

			private bool _ownsSheets = true;

			public RuntimeBuildState(string manifest, IReadOnlyList<SourceEmoji> sources)
			{
				ManifestHash = ComputeSha256(Encoding.UTF8.GetBytes(manifest)).Substring(0, 12);
				EmojiSources = sources.Where((SourceEmoji source) => source.Record.Role == MediaRole.Emoji).ToArray();
				EmblemSources = sources.Where((SourceEmoji source) => source.Record.Role == MediaRole.Emblem).ToArray();
				if (EmblemSources.Any((SourceEmoji source) => source.Frames.Count != 1))
				{
					throw new InvalidDataException("Clan emblems must contain exactly one PNG frame.");
				}
				StillSources = EmojiSources.Where((SourceEmoji source) => source.Frames.Count == 1).ToArray();
				AnimatedSources = EmojiSources.Where((SourceEmoji source) => source.Frames.Count > 1).ToArray();
			}

			public void ReleaseOwnership()
			{
				_ownsSheets = false;
				Sheets.Clear();
				EmojiSheets.Clear();
				References.Clear();
			}

			public void Destroy()
			{
				if (!_ownsSheets)
				{
					return;
				}
				_ownsSheets = false;
				foreach (RuntimeSheet sheet in Sheets)
				{
					sheet.SpriteAsset.fallbackSpriteAssets?.Clear();
				}
				foreach (RuntimeSheet sheet2 in Sheets)
				{
					DestroyRuntimeSheet(sheet2);
				}
				Sheets.Clear();
				EmojiSheets.Clear();
				References.Clear();
			}
		}

		private sealed class SourceEmoji
		{
			public readonly ManifestRecord Record;

			public readonly int Width;

			public readonly int Height;

			public readonly IReadOnlyList<byte[]> Frames;

			public readonly int FramesPerSecond;

			public SourceEmoji(ManifestRecord record, int width, int height, IReadOnlyList<byte[]> frames, int framesPerSecond)
			{
				Record = record;
				Width = width;
				Height = height;
				Frames = frames;
				FramesPerSecond = framesPerSecond;
			}

			public SourceEmoji WithRecord(ManifestRecord record)
			{
				return new SourceEmoji(record, Width, Height, Frames, FramesPerSecond);
			}
		}

		private sealed class FrameSpec
		{
			public readonly SourceEmoji Source;

			public readonly int FrameIndex;

			public readonly string SpriteName;

			public byte[] Pixels => Source.Frames[FrameIndex];

			public FrameSpec(SourceEmoji source, int frameIndex, string spriteName)
			{
				Source = source;
				FrameIndex = frameIndex;
				SpriteName = spriteName;
			}
		}

		private sealed class SourceRuntimeReference
		{
			public readonly RuntimeSheet Sheet;

			public readonly int FirstFrameIndex;

			public SourceRuntimeReference(RuntimeSheet sheet, int firstFrameIndex)
			{
				Sheet = sheet;
				FirstFrameIndex = firstFrameIndex;
			}
		}

		private sealed class RuntimeEmoji
		{
			public readonly string Token;

			public readonly Sprite PickerSprite;

			public readonly bool IsGif;

			public RuntimeEmoji(string token, Sprite pickerSprite, bool isGif)
			{
				Token = token;
				PickerSprite = pickerSprite;
				IsGif = isGif;
			}
		}

		internal readonly struct ClanEmblemPickerItem
		{
			public readonly string Name;

			public readonly Sprite Sprite;

			public ClanEmblemPickerItem(string name, Sprite sprite)
			{
				Name = name;
				Sprite = sprite;
			}
		}

		private sealed class RuntimeRenderTag
		{
			public readonly string AnimatedTag;

			public readonly string StaticTag;

			public readonly bool IsAnimated;

			public RuntimeRenderTag(string animatedTag, string staticTag, bool isAnimated)
			{
				AnimatedTag = animatedTag;
				StaticTag = staticTag;
				IsAnimated = isAnimated;
			}
		}

		private sealed class RuntimeSheet
		{
			public readonly Texture2D Texture;

			public readonly TMP_SpriteAsset SpriteAsset;

			public readonly Material Material;

			public readonly Sprite[] Sprites;

			public RuntimeSheet(Texture2D texture, TMP_SpriteAsset spriteAsset, Material material, Sprite[] sprites)
			{
				Texture = texture;
				SpriteAsset = spriteAsset;
				Material = material;
				Sprites = sprites;
			}
		}

		private sealed class RuntimeLibrary
		{
			public readonly TMP_SpriteAsset? RootSpriteAsset;

			public readonly IReadOnlyList<RuntimeSheet> Sheets;

			public readonly IReadOnlyList<RuntimeEmoji> Entries;

			public readonly IReadOnlyList<ClanEmblemPickerItem> Emblems;

			public readonly IReadOnlyDictionary<string, ClanEmblemPickerItem> EmblemsByName;

			public readonly IReadOnlyDictionary<string, RuntimeRenderTag> RenderTags;

			public readonly Regex TokenRegex;

			public readonly IReadOnlyDictionary<string, RuntimeRenderTag> RenderTagsBySpriteName;

			public readonly Regex SpriteTagRegex;

			public RuntimeLibrary(TMP_SpriteAsset? rootSpriteAsset, IReadOnlyList<RuntimeSheet> sheets, IReadOnlyList<RuntimeEmoji> entries, IReadOnlyList<ClanEmblemPickerItem> emblems, IReadOnlyDictionary<string, ClanEmblemPickerItem> emblemsByName, IReadOnlyDictionary<string, RuntimeRenderTag> renderTags, Regex tokenRegex, IReadOnlyDictionary<string, RuntimeRenderTag> renderTagsBySpriteName, Regex spriteTagRegex)
			{
				RootSpriteAsset = rootSpriteAsset;
				Sheets = sheets;
				Entries = entries;
				Emblems = emblems;
				EmblemsByName = emblemsByName;
				RenderTags = renderTags;
				TokenRegex = tokenRegex;
				RenderTagsBySpriteName = renderTagsBySpriteName;
				SpriteTagRegex = spriteTagRegex;
			}
		}

		private enum EmojiFileResponseStatus : byte
		{
			Data,
			Busy,
			StaleCatalog,
			Unavailable,
			Rejected
		}

		private enum SyncedMediaFileSource : byte
		{
			None,
			Server,
			Cache,
			Config
		}

		private sealed class ServerEmojiBlob
		{
			public readonly ManifestRecord Record;

			public readonly byte[] Data;

			public readonly int GifFrameCount;

			public ServerEmojiBlob(ManifestRecord record, byte[] data, int gifFrameCount)
			{
				Record = record;
				Data = data;
				GifFrameCount = gifFrameCount;
			}
		}

		private sealed class ServerEmojiCatalog
		{
			public readonly string Manifest;

			public readonly string CatalogId;

			public readonly IReadOnlyList<ManifestRecord> Records;

			public readonly IReadOnlyDictionary<string, ServerEmojiBlob> Files;

			public ServerEmojiCatalog(string manifest, string catalogId, IReadOnlyList<ManifestRecord> records, IReadOnlyDictionary<string, ServerEmojiBlob> files)
			{
				Manifest = manifest;
				CatalogId = catalogId;
				Records = records;
				Files = files;
			}
		}

		private sealed class ClientEmojiCatalog
		{
			public readonly ZNet? Session;

			public readonly string Manifest;

			public readonly string CatalogId;

			public readonly IReadOnlyList<ManifestRecord> Records;

			public int NextRecordIndex;

			public int ServerHits;

			public int CacheHits;

			public int ConfigHits;

			public int Downloads;

			public ClientEmojiDownload? Download;

			public bool Ready;

			public bool Failed;

			public int CatalogRetryCount;

			public float CatalogRetryAt;

			public ClientEmojiCatalog(ZNet? session, string manifest, string catalogId, IReadOnlyList<ManifestRecord> records)
			{
				Session = session;
				Manifest = manifest;
				CatalogId = catalogId;
				Records = records;
			}
		}

		private sealed class ClientEmojiDownload
		{
			private const byte Missing = 0;

			private const byte InFlight = 1;

			private const byte Received = 2;

			public readonly ManifestRecord Record;

			public readonly byte[] Buffer;

			private readonly byte[] _chunkStates;

			private readonly int[] _requestIds;

			private readonly int[] _retryCounts;

			private readonly float[] _nextRequestAt;

			private readonly float[] _responseDeadlines;

			private int _nextChunkCursor;

			private int _receivedBytes;

			public int ChunkCount => _chunkStates.Length;

			public int InFlightCount { get; private set; }

			public bool Completed => _receivedBytes == Buffer.Length;

			public ClientEmojiDownload(ManifestRecord record)
			{
				Record = record;
				Buffer = new byte[record.Length];
				int num = (record.Length + 65536 - 1) / 65536;
				_chunkStates = new byte[num];
				_requestIds = new int[num];
				_retryCounts = new int[num];
				_nextRequestAt = new float[num];
				_responseDeadlines = new float[num];
			}

			public bool TryGetChunkIndex(int offset, out int chunkIndex)
			{
				chunkIndex = offset / 65536;
				if (offset >= 0 && offset % 65536 == 0 && offset < Buffer.Length && chunkIndex >= 0)
				{
					return chunkIndex < ChunkCount;
				}
				return false;
			}

			public bool HasIssuedRequest(int chunkIndex, int requestId)
			{
				if (requestId > 0)
				{
					return requestId <= _requestIds[chunkIndex];
				}
				return false;
			}

			public bool IsCurrentRequest(int chunkIndex, int requestId)
			{
				if (_chunkStates[chunkIndex] == 1)
				{
					return _requestIds[chunkIndex] == requestId;
				}
				return false;
			}

			public bool IsChunkReceived(int chunkIndex)
			{
				return _chunkStates[chunkIndex] == 2;
			}

			public bool IsResponseTimedOut(int chunkIndex, float now)
			{
				if (_chunkStates[chunkIndex] == 1)
				{
					return now >= _responseDeadlines[chunkIndex];
				}
				return false;
			}

			public bool TryGetNextRequestChunk(float now, out int chunkIndex)
			{
				for (int i = 0; i < ChunkCount; i++)
				{
					int num = (_nextChunkCursor + i) % ChunkCount;
					if (_chunkStates[num] == 0 && !(now < _nextRequestAt[num]))
					{
						_nextChunkCursor = (num + 1) % ChunkCount;
						chunkIndex = num;
						return true;
					}
				}
				chunkIndex = -1;
				return false;
			}

			public int MarkRequested(int chunkIndex, float responseDeadline)
			{
				if (_chunkStates[chunkIndex] != 0)
				{
					throw new InvalidOperationException("Media chunk is already in flight.");
				}
				int result = ++_requestIds[chunkIndex];
				_chunkStates[chunkIndex] = 1;
				_responseDeadlines[chunkIndex] = responseDeadline;
				InFlightCount++;
				return result;
			}

			public void MarkReceived(int chunkIndex, int length)
			{
				if (_chunkStates[chunkIndex] != 2)
				{
					if (_chunkStates[chunkIndex] == 1)
					{
						InFlightCount--;
					}
					_chunkStates[chunkIndex] = 2;
					_retryCounts[chunkIndex] = 0;
					_receivedBytes += length;
					if (_receivedBytes > Buffer.Length)
					{
						throw new InvalidDataException("Received media chunks exceed the manifest length.");
					}
				}
			}

			public int IncrementRetry(int chunkIndex)
			{
				return ++_retryCounts[chunkIndex];
			}

			public void DeferChunk(int chunkIndex, float nextRequestAt)
			{
				if (_chunkStates[chunkIndex] != 2)
				{
					if (_chunkStates[chunkIndex] == 1)
					{
						InFlightCount--;
					}
					_chunkStates[chunkIndex] = 0;
					_nextRequestAt[chunkIndex] = Math.Max(_nextRequestAt[chunkIndex], nextRequestAt);
				}
			}
		}

		private sealed class PeerTransferBudget
		{
			private float _lastRefillAt;

			private float _malformedWindowStartedAt;

			private double _requestTokens;

			public double ByteTokens;

			public int MalformedLogs;

			public PeerTransferBudget(float now)
			{
				_lastRefillAt = now;
				_malformedWindowStartedAt = now;
				_requestTokens = 32.0;
				ByteTokens = 262144.0;
			}

			public void Refill(float now)
			{
				float num = Math.Max(0f, now - _lastRefillAt);
				_lastRefillAt = now;
				_requestTokens = Math.Min(32.0, _requestTokens + (double)(num * 64f));
				ByteTokens = Math.Min(262144.0, ByteTokens + (double)(num * (2635359f / (float)Math.PI)));
			}

			public bool TryConsumeRequest(float now)
			{
				Refill(now);
				if (_requestTokens < 1.0)
				{
					return false;
				}
				_requestTokens -= 1.0;
				return true;
			}

			public bool TryConsumeMalformedLog(float now)
			{
				if (now < _malformedWindowStartedAt || now - _malformedWindowStartedAt >= 10f)
				{
					_malformedWindowStartedAt = now;
					MalformedLogs = 0;
				}
				if (MalformedLogs >= 3)
				{
					return false;
				}
				MalformedLogs++;
				return true;
			}
		}

		private sealed class GlobalTransferBudget
		{
			private float _lastRefillAt = -1f;

			public double ByteTokens { get; set; }

			public GlobalTransferBudget()
			{
				Reset();
			}

			public void Reset()
			{
				_lastRefillAt = -1f;
				ByteTokens = 1048576.0;
			}

			public void Refill(float now)
			{
				if (_lastRefillAt < 0f || now < _lastRefillAt)
				{
					_lastRefillAt = now;
					return;
				}
				float num = now - _lastRefillAt;
				_lastRefillAt = now;
				ByteTokens = Math.Min(1048576.0, ByteTokens + (double)(num * (10541436f / (float)Math.PI)));
			}
		}

		private const int MaximumEmojiFiles = 100;

		private const int MaximumPngFiles = 100;

		private const int MaximumGifFiles = 50;

		private const int MaximumEmblemFiles = 50;

		private const int MaximumPngSourceBytes = 524288;

		private const int MaximumGifSourceBytes = 2097152;

		private const int MaximumSourceDimension = 512;

		private const int MaximumGifFrames = 180;

		private const int MaximumTotalGifFrames = 3000;

		private const long MaximumGifDecodedPixels = 8388608L;

		private const long MaximumGifDurationMilliseconds = 10000L;

		private const int MaximumRenderedDimension = 96;

		private const int MaximumGifPlaybackFps = 50;

		private const int MaximumEmojiOccurrencesPerMessage = 5;

		private const int MaximumAnimatedOccurrencesPerChatPanel = 15;

		private const int EmojiSizePercent = 200;

		private const int AtlasGutter = 2;

		private const int AtlasColumns = 5;

		private const long MediaCacheRetryDelayTicks = 10000000L;

		private const int MaximumManifestCharacters = 24576;

		private const string ManifestVersion = "v4";

		private const string SpriteAssetVersion = "1.1.0";

		private const string TokenPrefix = ":clan_";

		private const string SpriteNamePrefix = "clan_emoji_";

		private const string PngSpriteNamePrefix = "clan_emoji_png_";

		private const string GifSpriteNamePrefix = "clan_emoji_gif_";

		private const string EmblemSpriteNamePrefix = "clan_emblem_";

		private static readonly byte[] PngSignature = new byte[8] { 137, 80, 78, 71, 13, 10, 26, 10 };

		private static readonly Regex SafeNameRegex = new Regex("^[a-z0-9](?:[a-z0-9_-]{0,30}[a-z0-9])?$", RegexOptions.Compiled | RegexOptions.CultureInvariant);

		private static readonly HashSet<string> ReservedWindowsNames = BuildReservedWindowsNames();

		private static readonly StringComparer FilePathComparer = ((Environment.OSVersion.Platform == PlatformID.Win32NT) ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);

		private static readonly object ServerMediaDirtyLock = new object();

		private static readonly SemaphoreSlim GifDecodeGate = new SemaphoreSlim(1, 1);

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

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

		private static long _serverMediaDirtyGeneration;

		private static readonly FieldInfo? SpriteAssetVersionField = typeof(TMP_Asset).GetField("m_Version", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly ConfigSync MediaConfigSync = new ConfigSync("sighsorry.Clan.media")
		{
			DisplayName = "Clan Media",
			CurrentVersion = "1.0.1",
			MinimumRequiredVersion = "1.0.1",
			ModRequired = false,
			IsLocked = true
		};

		private static readonly CustomSyncedValue<string> SyncedManifest = new CustomSyncedValue<string>(MediaConfigSync, "manifest", "");

		private static bool _initialized;

		private static bool _mediaCacheInitialized;

		private static bool _mediaCacheWarningLogged;

		private static long _mediaCacheRetryAtTicks;

		private static bool _serverManifestPublishRetryPending;

		private static ZNet? _session;

		private static RuntimeLibrary? _runtime;

		private static BuildState? _build;

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

		private static string _activeManifest = "";

		private static IReadOnlyList<ManifestRecord> _activeRecords = Array.Empty<ManifestRecord>();

		private static string _waitingManifest = "";

		private static List<ManifestRecord>? _waitingRecords;

		private static PendingManifestState? _pendingManifest;

		private static TMP_Text? _attachedOutput;

		private static TMP_SpriteAsset? _fallbackOwner;

		private static bool _installedAsPrimary;

		private static bool _addedFallback;

		private const int EmojiFileProtocolVersion = 3;

		private const int EmojiChunkBytes = 65536;

		private const int MaximumParallelEmojiChunks = 4;

		private const int MaximumEmojiRequestBytes = 512;

		private const int MaximumEmojiResponseBytes = 66048;

		private const int MaximumChunkRetries = 3;

		private const float ChunkResponseTimeoutSeconds = 5f;

		private const long EmojiCacheMaximumBytes = 402653184L;

		private const long EmojiCacheTrimmedBytes = 335544320L;

		private const long PartialEmojiCacheMaximumAgeTicks = 864000000000L;

		private const long EmojiReloadDebounceTicks = 7500000L;

		private const int MaximumReloadRetries = 3;

		private const float PeerRequestTokensPerSecond = 64f;

		private const float PeerRequestTokenCapacity = 32f;

		private const float PeerTransferBytesPerSecond = 2635359f / (float)Math.PI;

		private const float PeerTransferByteCapacity = 262144f;

		private const float GlobalTransferBytesPerSecond = 10541436f / (float)Math.PI;

		private const float GlobalTransferByteCapacity = 1048576f;

		private const int MaximumMediaSendQueueBytes = 262144;

		private const float MalformedLogWindowSeconds = 10f;

		private static readonly string EmojiFileRequestRpc = string.Format("{0}.media.file.request.v{1}", "sighsorry.Clan", 3);

		private static readonly string EmojiFileResponseRpc = string.Format("{0}.media.file.response.v{1}", "sighsorry.Clan", 3);

		private static readonly Dictionary<ZRpc, PeerTransferBudget> EmojiPeerBudgets = new Dictionary<ZRpc, PeerTransferBudget>();

		private static readonly GlobalTransferBudget EmojiGlobalTransferBudget = new GlobalTransferBudget();

		private static ServerEmojiCatalog? _serverEmojiCatalog;

		private static ClientEmojiCatalog? _clientEmojiCatalog;

		private static FileSystemWatcher? _emojiFileWatcher;

		private static FileSystemWatcher? _emblemFileWatcher;

		private static long _emojiReloadRequestedAtTicks;

		private static int _emojiReloadFailures;

		private static int _emojiWatcherNeedsRestart;

		private static int _emojiWatcherRestartFailures;

		public static bool IsReady
		{
			get
			{
				if (_runtime != null)
				{
					return _runtime.Entries.Count > 0;
				}
				return false;
			}
		}

		public static int EmojiCount => _runtime?.Entries.Count ?? 0;

		internal static int MessageEmojiLimit => 5;

		private static string EmojiDirectory => Path.Combine(ClanPlugin.MediaDirectory, "emoji");

		private static string EmblemDirectory => Path.Combine(ClanPlugin.MediaDirectory, "emblems");

		private static string EmojiCacheDirectory => Path.Combine(ClanPlugin.DataDirectory, "cache");

		private static bool HasEmojiServerCatalog => _serverEmojiCatalog != null;

		public static event Action? EmojiChanged;

		public static event Action? EmblemsChanged;

		internal static IReadOnlyList<ClanEmblemPickerItem> GetEmblemPickerItems()
		{
			if (_runtime == null)
			{
				return Array.Empty<ClanEmblemPickerItem>();
			}
			return _runtime.Emblems;
		}

		internal static Sprite? GetEmblemSprite(string? name)
		{
			if (_runtime == null || string.IsNullOrWhiteSpace(name))
			{
				return null;
			}
			if (!_runtime.EmblemsByName.TryGetValue(name, out var value))
			{
				return null;
			}
			return value.Sprite;
		}

		internal static bool IsAvailableEmblemKey(string? name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return true;
			}
			if (!IsSafeName(name))
			{
				return false;
			}
			if (_serverEmojiCatalog != null)
			{
				return _serverEmojiCatalog.Records.Any((ManifestRecord record) => record.Role == MediaRole.Emblem && StringComparer.Ordinal.Equals(record.Name, name));
			}
			if (_runtime != null)
			{
				return _runtime.EmblemsByName.ContainsKey(name);
			}
			return false;
		}

		internal static void MarkEmojiServerFileDirty(string path)
		{
			try
			{
				string fullPath = Path.GetFullPath(path);
				lock (ServerMediaDirtyLock)
				{
					DirtyServerMediaPaths[fullPath] = ++_serverMediaDirtyGeneration;
				}
			}
			catch (Exception ex) when (((ex is ArgumentException || ex is NotSupportedException || ex is PathTooLongException) ? 1 : 0) != 0)
			{
			}
			MarkEmojiServerFilesDirty();
		}

		private static Dictionary<string, long> SnapshotDirtyServerMediaPaths()
		{
			lock (ServerMediaDirtyLock)
			{
				return new Dictionary<string, long>(DirtyServerMediaPaths, FilePathComparer);
			}
		}

		private static bool IsServerMediaPathDirty(string path, IReadOnlyDictionary<string, long> dirtyPaths)
		{
			return dirtyPaths.ContainsKey(Path.GetFullPath(path));
		}

		private static void AcknowledgeDirtyServerMediaPaths(IReadOnlyDictionary<string, long> dirtyPaths, IEnumerable<string> retryablePaths)
		{
			HashSet<string> hashSet = retryablePaths.Select(Path.GetFullPath).ToHashSet<string>(FilePathComparer);
			lock (ServerMediaDirtyLock)
			{
				foreach (KeyValuePair<string, long> dirtyPath in dirtyPaths)
				{
					if (!hashSet.Contains(dirtyPath.Key) && DirtyServerMediaPaths.TryGetValue(dirtyPath.Key, out var value) && value == dirtyPath.Value)
					{
						DirtyServerMediaPaths.Remove(dirtyPath.Key);
					}
				}
			}
		}

		public static void Init()
		{
			if (!_initialized)
			{
				_initialized = true;
				SyncedManifest.ValueChanged += OnSyncedManifestChanged;
			}
		}

		private static bool EnsureMediaCacheInitialized()
		{
			if (_mediaCacheInitialized)
			{
				return true;
			}
			long ticks = DateTime.UtcNow.Ticks;
			if (ticks < _mediaCacheRetryAtTicks)
			{
				return false;
			}
			_mediaCacheRetryAtTicks = ticks + 10000000;
			try
			{
				InitializeEmojiCache();
				_mediaCacheInitialized = true;
				_mediaCacheRetryAtTicks = 0L;
				if (_mediaCacheWarningLogged)
				{
					ClanPlugin.ClanLogger.LogInfo((object)"Clan media cache initialization recovered.");
					_mediaCacheWarningLogged = false;
				}
				return true;
			}
			catch (Exception ex)
			{
				if (!_mediaCacheWarningLogged)
				{
					ClanPlugin.ClanLogger.LogWarning((object)("Clan media cache is not ready and will be retried: " + ex.Message));
					_mediaCacheWarningLogged = true;
				}
				return false;
			}
		}

		public static void Dispose()
		{
			if (_initialized)
			{
				SyncedManifest.ValueChanged -= OnSyncedManifestChanged;
				_session = null;
				_pendingManifest = null;
				_mediaCacheInitialized = false;
				_mediaCacheWarningLogged = false;
				_mediaCacheRetryAtTicks = 0L;
				ResetMediaSessionState(null);
				_initialized = false;
			}
		}

		private static void ResetMediaSessionState(ZNet? session)
		{
			CancelBuild();
			_preparedSources.Clear();
			_activeManifest = "";
			_activeRecords = Array.Empty<ManifestRecord>();
			_waitingManifest = "";
			_waitingRecords = null;
			ResetEmojiSyncSession(session);
			ReplaceRuntime(null);
		}

		public static void Tick()
		{
			if (!_initialized)
			{
				return;
			}
			ZNet instance = ZNet.instance;
			if (instance != _session)
			{
				_session = instance;
				if (_pendingManifest != null && _pendingManifest.Session != instance)
				{
					_pendingManifest = null;
				}
				ResetMediaSessionState(instance);
				if (instance != null && instance.IsServer())
				{
					LoadServerManifest(preserveLastGood: false);
				}
			}
			if ((Object)(object)instance != (Object)null && !instance.IsServer() && !EnsureMediaCacheInitialized())
			{
				return;
			}
			if (instance != null && instance.IsServer() && ConsumeEmojiServerReloadRequest())
			{
				LoadServerManifest(preserveLastGood: true);
			}
			if (GUIManager.IsHeadless())
			{
				return;
			}
			PendingManifestState pendingManifest = _pendingManifest;
			if (pendingManifest != null)
			{
				_pendingManifest = null;
				if (pendingManifest.Session == ZNet.instance)
				{
					StartBuild(pendingManifest.Manifest);
				}
			}
			TickEmojiSync();
			StartReadyEmojiBuild();
			ProcessBuildStep();
			EnsureOutputAttachment();
		}

		public static Sprite? GetPickerSprite(int index)
		{
			if (_runtime == null || index < 0 || index >= _runtime.Entries.Count)
			{
				return null;
			}
			return _runtime.Entries[index].PickerSprite;
		}

		internal static bool IsGifEmoji(int index)
		{
			if (_runtime != null && index >= 0 && index < _runtime.Entries.Count)
			{
				return _runtime.Entries[index].IsGif;
			}
			return false;
		}

		public static string TokenFor(int index)
		{
			if (_runtime == null || index < 0 || index >= _runtime.Entries.Count)
			{
				return "";
			}
			return _runtime.Entries[index].Token;
		}

		internal static int CountMessageEmojiTokens(string? text)
		{
			if (_runtime == null || string.IsNullOrEmpty(text))
			{
				return 0;
			}
			return _runtime.TokenRegex.Matches(text).Count;
		}

		internal static bool IsWithinMessageEmojiLimit(string? text)
		{
			return CountMessageEmojiTokens(text) <= 5;
		}

		public static string RenderTokens(string text)
		{
			if (_runtime == null || string.IsNullOrEmpty(text) || text.IndexOf(":clan_", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text;
			}
			int emojiOccurrences = 0;
			int previousMatchEnd = 0;
			return _runtime.TokenRegex.Replace(text, delegate(Match match)
			{
				if (ContainsLineBreak(text, previousMatchEnd, match.Index))
				{
					emojiOccurrences = 0;
				}
				previousMatchEnd = match.Index + match.Length;
				if (!_runtime.RenderTags.TryGetValue(match.Value, out RuntimeRenderTag value))
				{
					return match.Value;
				}
				emojiOccurrences++;
				if (emojiOccurrences > 5)
				{
					return EscapeTokenForDisplay(match.Value);
				}
				string arg = (value.IsAnimated ? value.AnimatedTag : value.StaticTag);
				return $"<size={200}%>{arg}</size>";
			});
		}

		private static bool ContainsLineBreak(string text, int startIndex, int endIndex)
		{
			for (int i = startIndex; i < endIndex; i++)
			{
				char c = text[i];
				if ((c == '\n' || c == '\r') ? true : false)
				{
					return true;
				}
			}
			return false;
		}

		private static string EscapeTokenForDisplay(string token)
		{
			if (token.Length != 0)
			{
				return token.Insert(1, "\u200b");
			}
			return token;
		}

		private static int CountAnimatedSpriteOccurrences(string text)
		{
			RuntimeLibrary runtime = _runtime;
			if (runtime == null || string.IsNullOrEmpty(text))
			{
				return 0;
			}
			int num = 0;
			foreach (Match item in runtime.SpriteTagRegex.Matches(text))
			{
				if (runtime.RenderTagsBySpriteName.TryGetValue(item.Groups["name"].Value, out RuntimeRenderTag value) && value.IsAnimated)
				{
					num++;
				}
			}
			return num;
		}

		private static string RewriteAnimatedSpriteTags(string text, ref int animatedOrdinal, int animatedOccurrencesToFreeze)
		{
			RuntimeLibrary runtime = _runtime;
			if (runtime == null || string.IsNullOrEmpty(text))
			{
				return text;
			}
			int ordinal = animatedOrdinal;
			string result = runtime.SpriteTagRegex.Replace(text, delegate(Match match)
			{
				if (!runtime.RenderTagsBySpriteName.TryGetValue(match.Groups["name"].Value, out RuntimeRenderTag value))
				{
					return match.Value;
				}
				if (!value.IsAnimated)
				{
					return value.StaticTag;
				}
				return (ordinal++ >= animatedOccurrencesToFreeze) ? value.AnimatedTag : value.StaticTag;
			});
			animatedOrdinal = ordinal;
			return result;
		}

		private static string ApplyAnimatedSpriteBudget(string text, int budget)
		{
			int num = CountAnimatedSpriteOccurrences(text);
			int animatedOccurrencesToFreeze = Math.Max(0, num - budget);
			int animatedOrdinal = 0;
			return RewriteAnimatedSpriteTags(text, ref animatedOrdinal, animatedOccurrencesToFreeze);
		}

		private static void LoadServerManifest(bool preserveLastGood)
		{
			Dictionary<string, long> dirtyPaths;
			Dictionary<string, ServerFileStamp> dictionary;
			List<string> list;
			List<Exception> list2;
			List<string> list3;
			List<ManifestRecord> list4;
			string text;
			bool flag;
			bool serverManifestPublishRetryPending;
			ServerEmojiCatalog serverEmojiCatalog;
			try
			{
				Directory.CreateDirectory(EmojiDirectory);
				Directory.CreateDirectory(EmblemDirectory);
				dirtyPaths = SnapshotDirtyServerMediaPaths();
				List<ServerEmojiBlob> blobs = new List<ServerEmojiBlob>();
				dictionary = new Dictionary<string, ServerFileStamp>(StringComparer.Ordinal);
				list = new List<string>();
				list2 = new List<Exception>();
				list3 = new List<string>();
				list4 = DiscoverServerFiles(preserveLastGood, dirtyPaths, blobs, dictionary, list, list2, list3);
				text = SerializeManifest(list4);
				flag = !IsCurrentEmojiServerManifest(text);
				serverEmojiCatalog = (flag ? PrepareEmojiServerCatalog(text, list4, blobs) : null);
				serverManifestPublishRetryPending = _serverManifestPublishRetryPending;
				if (!preserveLastGood || serverManifestPublishRetryPending || !StringComparer.Ordinal.Equals(SyncedManifest.Value, text))
				{
					try
					{
						SyncedManifest.Value = text;
						_serverManifestPublishRetryPending = false;
					}
					catch (Exception ex)
					{
						_serverManifestPublishRetryPending = true;
						bool flag2 = StringComparer.Ordinal.Equals(SyncedManifest.Value, text);
						if (flag2 && serverEmojiCatalog != null)
						{
							CommitEmojiServerCatalog(serverEmojiCatalog);
							serverEmojiCatalog = null;
						}
						ScheduleEmojiServerReloadRetry(ex, retryAnyError: true);
						if (flag2 && !GUIManager.IsHeadless())
						{
							QueueManifest(text);
						}
						ClanPlugin.ClanLogger.LogWarning((object)(flag2 ? ("Clan media manifest was assigned, but its synchronization failed and will be retried: " + ex.Message) : ("Clan media manifest synchronization failed; the last valid catalog remains active and publication will be retried: " + ex.Message)));
						return;
					}
				}
			}
			catch (Exception ex2)
			{
				if (preserveLastGood && HasEmojiServerCatalog)
				{
					ScheduleEmojiServerReloadRetry(ex2);
					ClanPlugin.ClanLogger.LogWarning((object)("Clan media hot reload was rejected; the last valid catalog remains active: " + ex2.Message));
					return;
				}
				if (_serverManifestPublishRetryPending || !StringComparer.Ordinal.Equals(SyncedManifest.Value, ""))
				{
					try
					{
						SyncedManifest.Value = "";
						_serverManifestPublishRetryPending = false;
					}
					catch (Exception ex3)
					{
						_serverManifestPublishRetryPending = true;
						bool flag3 = StringComparer.Ordinal.Equals(SyncedManifest.Value, "");
						ScheduleEmojiServerReloadRetry(ex3, retryAnyError: true);
						if (flag3)
						{
							ClearEmojiServerCatalog();
							if (!GUIManager.IsHeadless())
							{
								QueueManifest("");
							}
						}
						ClanPlugin.ClanLogger.LogWarning((object)(flag3 ? ("Clan media was disabled after catalog loading failed, but empty-manifest synchronization also failed and remains pending: " + ex3.Message) : ("Clan media catalog loading failed and the previous manifest could not be replaced; publication remains pending: " + ex3.Message)));
						return;
					}
				}
				ClearEmojiServerCatalog();
				if (!GUIManager.IsHeadless())
				{
					QueueManifest("");
				}
				ClanPlugin.ClanLogger.LogError((object)("Clan media manifest was disabled: " + ex2.Message));
				return;
			}
			if (serverEmojiCatalog != null)
			{
				CommitEmojiServerCatalog(serverEmojiCatalog);
			}
			if ((flag || serverManifestPublishRetryPending) && !GUIManager.IsHeadless())
			{
				QueueManifest(text);
			}
			try
			{
				AcknowledgeDirtyServerMediaPaths(dirtyPaths, list3);
				_serverFileStamps = dictionary;
				if (list2.Count == 0)
				{
					ResetEmojiServerReloadFailures();
				}
				else
				{
					ScheduleEmojiServerReloadRetry(list2[0]);
				}
				foreach (string item in list)
				{
					ClanPlugin.ClanLogger.LogWarning((object)item);
				}
				if (!flag)
				{
					return;
				}
				if (list4.Count == 0)
				{
					if (list.Count == 0)
					{
						ClanPlugin.ClanLogger.LogInfo((object)($"Clan media folders are empty. Put up to {100} total PNG/GIF " + $"emoji files (up to {100} PNG or {50} GIF) " + "in '" + EmojiDirectory + "', and up to " + $"{50} PNG emblem files in '{EmblemDirectory}'."));
					}
					else
					{
						ClanPlugin.ClanLogger.LogWarning((object)"No valid Clan media files are available; invalid files were skipped.");
					}
				}
				else
				{
					int num = list4.Count((ManifestRecord record) => record.Role == MediaRole.Emoji && record.Kind == EmojiFileKind.Png);
					int num2 = list4.Count((ManifestRecord record) => record.Role == MediaRole.Emoji && record.Kind == EmojiFileKind.Gif);
					int num3 = list4.Count((ManifestRecord record) => record.Role == MediaRole.Emblem);
					ClanPlugin.ClanLogger.LogInfo((object)($"Published Clan media catalog for {num} PNG emoji, {num2} GIF emoji, " + $"and {num3} PNG emblem files. " + "Clients download only content missing from verified local media and their SHA-256 cache."));
				}
			}
			catch (Exception ex4)
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Clan media catalog is active, but post-publish maintenance could not be completed: " + ex4.Message));
			}
		}

		private static List<ManifestRecord> DiscoverServerFiles(bool preserveLastGood, IReadOnlyDictionary<string, long> dirtyPaths, ICollection<ServerEmojiBlob> blobs, IDictionary<string, ServerFileStamp> fileStamps, ICollection<string> warnings, ICollection<Exception> retryableFileErrors, ICollection<string> retryableFilePaths)
		{
			List<ManifestRecord> list = new List<ManifestRecord>();
			Dictionary<string, ServerFileCandidate> previousServerFiles = GetPreviousServerFiles(preserveLastGood);
			DiscoverServerFiles(MediaRole.Emoji, EmojiDirectory, 100, 50, 100, dirtyPaths, previousServerFiles, blobs, fileStamps, list, warnings, retryableFileErrors, retryableFilePaths);
			DiscoverServerFiles(MediaRole.Emblem, EmblemDirectory, 50, 0, 50, dirtyPaths, previousServerFiles, blobs, fileStamps, list, warnings, retryableFileErrors, retryableFilePaths);
			return list;
		}

		private static Dictionary<string, ServerFileCandidate> GetPreviousServerFiles(bool preserveLastGood)
		{
			Dictionary<string, ServerFileCandidate> dictionary = new Dictionary<string, ServerFileCandidate>(StringComparer.Ordinal);
			if (!preserveLastGood || _serverEmojiCatalog == null)
			{
				return dictionary;
			}
			foreach (ManifestRecord record in _serverEmojiCatalog.Records)
			{
				if (_serverEmojiCatalog.Files.TryGetValue(record.Hash, out ServerEmojiBlob value) && value.Data.Length == record.Length)
				{
					string key = MediaKey(record.Role, record.Name);
					_serverFileStamps.TryGetValue(key, out ServerFileStamp value2);
					dictionary[key] = new ServerFileCandidate(new ServerEmojiBlob(record, value.Data, value.GifFrameCount), value2);
				}
			}
			return dictionary;
		}

		private static void DiscoverServerFiles(MediaRole role, string sourceDirectory, int maximumPngFiles, int maximumGifFiles, int maximumTotalFiles, IReadOnlyDictionary<string, long> dirtyPaths, IReadOnlyDictionary<string, ServerFileCandidate> previousByKey, ICollection<ServerEmojiBlob> blobs, IDictionary<string, ServerFileStamp> fileStamps, ICollection<ManifestRecord> records, ICollection<string> warnings, ICollection<Exception> retryableFileErrors, ICollection<string> retryableFilePaths)
		{
			List<FileInfo> list = (from file in new DirectoryInfo(sourceDirectory).EnumerateFiles("*", SearchOption.TopDirectoryOnly)
				where StringComparer.Ordinal.Equals(file.Extension, ".png") || StringComparer.Ordinal.Equals(file.Extension, ".gif")
				select file).OrderBy<FileInfo, string>((FileInfo file) => file.Name, StringComparer.Ordinal).ToList();
			string text = ((role == MediaRole.Emoji) ? "emoji" : "emblem");
			List<(FileInfo, string, EmojiFileKind)> list2 = new List<(FileInfo, string, EmojiFileKind)>();
			foreach (FileInfo item2 in list)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item2.Name);
				if (!IsSafeName(fileNameWithoutExtension))
				{
					warnings.Add("Skipped " + text + " file '" + item2.Name + "': filename must use lowercase ASCII letters, digits, '_' or '-' only.");
				}
				else
				{
					EmojiFileKind item = ((!StringComparer.Ordinal.Equals(item2.Extension, ".png")) ? EmojiFileKind.Gif : EmojiFileKind.Png);
					list2.Add((item2, fileNameWithoutExtension, item));
				}
			}
			List<ServerFileCandidate> list3 = new List<ServerFileCandidate>();
			foreach (IGrouping<string, (FileInfo, string, EmojiFileKind)> item3 in list2.GroupBy<(FileInfo, string, EmojiFileKind), string>(((FileInfo File, string Name, EmojiFileKind Kind) candidate) => candidate.Name, StringComparer.Ordinal).OrderBy<IGrouping<string, (FileInfo, string, EmojiFileKind)>, string>((IGrouping<string, (FileInfo File, string Name, EmojiFileKind Kind)> group) => group.Key, StringComparer.Ordinal))
			{
				(FileInfo, string, EmojiFileKind)[] array = item3.ToArray();
				if (array.Length != 1)
				{
					RetainPreviousServerFile(role, item3.Key, previousByKey, list3, warnings, text + " basename '" + item3.Key + "' is used by more than one file");
					continue;
				}
				var (fileInfo, name, emojiFileKind) = array[0];
				try
				{
					if (emojiFileKind == EmojiFileKind.Gif && maximumGifFiles == 0)
					{
						throw new InvalidDataException("Clan emblems must be PNG files.");
					}
					ServerFileStamp serverFileStamp = ServerFileStamp.Capture(fileInfo);
					int maximumSourceBytes = GetMaximumSourceBytes(emojiFileKind);
					if (serverFileStamp.Length <= 0 || serverFileStamp.Length > maximumSourceBytes)
					{
						throw new InvalidDataException($"file size must be between 1 and {maximumSourceBytes} bytes");
					}
					string key = MediaKey(role, name);
					if (!IsServerMediaPathDirty(fileInfo.FullName, dirtyPaths) && previousByKey.TryGetValue(key, out ServerFileCandidate value) && value.Blob.Record.Kind == emojiFileKind && value.Stamp != null && value.Stamp.Matches(serverFileStamp))
					{
						list3.Add(value);
						continue;
					}
					byte[] array2 = ReadStableFile(fileInfo.FullName, serverFileStamp.Length);
					int gifFrameCount = 0;
					if (emojiFileKind == EmojiFileKind.Png)
					{
						ValidatePngHeader(array2, out var _, out var _);
					}
					else
					{
						ClanGifDecoder.Animation animation = ClanGifDecoder.Decode(array2, 2097152, 512, 180, 8388608L);
						ValidateGifAnimation(animation);
						gifFrameCount = animation.Frames.Count;
					}
					fileInfo.Refresh();
					ServerFileStamp serverFileStamp2 = ServerFileStamp.Capture(fileInfo);
					if (!serverFileStamp.Matches(serverFileStamp2))
					{
						throw new IOException("Media file '" + fileInfo.Name + "' changed while it was being validated.");
					}
					ManifestRecord record = new ManifestRecord(role, emojiFileKind, name, array2.Length, ComputeSha256(array2));
					list3.Add(new ServerFileCandidate(new ServerEmojiBlob(record, array2, gifFrameCount), serverFileStamp2));
				}
				catch (Exception ex) when (((ex is IOException || ex is UnauthorizedAccessException || ex is InvalidDataException) ? 1 : 0) != 0)
				{
					if ((ex is IOException || ex is InvalidDataException) ? true : false)
					{
						retryableFileErrors.Add(ex);
						retryableFilePaths.Add(fileInfo.FullName);
					}
					RetainPreviousServerFile(role, name, previousByKey, list3, warnings, "Rejected " + text + " file '" + fileInfo.Name + "': " + ex.Message);
				}
			}
			AddServerFilesWithinLimits(role, text, maximumPngFiles, maximumGifFiles, maximumTotalFiles, previousByKey, list3, blobs, fileStamps, records, warnings);
		}

		private static void RetainPreviousServerFile(MediaRole role, string name, IReadOnlyDictionary<string, ServerFileCandidate> previousByKey, ICollection<ServerFileCandidate> discovered, ICollection<string> warnings, string failure)
		{
			if (previousByKey.TryGetValue(MediaKey(role, name), out ServerFileCandidate value))
			{
				discovered.Add(value);
				warnings.Add(failure + "; keeping the previous valid version.");
			}
			else
			{
				warnings.Add(failure + "; the file was skipped.");
			}
		}

		private static void AddServerFilesWithinLimits(MediaRole role, string label, int maximumPngFiles, int maximumGifFiles, int maximumTotalFiles, IReadOnlyDictionary<string, ServerFileCandidate> previousByKey, IEnumerable<ServerFileCandidate> discovered, ICollection<ServerEmojiBlob> blobs, IDictionary<string, ServerFileStamp> fileStamps, ICollection<ManifestRecord> records, ICollection<string> warnings)
		{
			List<ServerFileCandidate> list = new List<ServerFileCandidate>();
			List<ServerFileCandidate> list2 = new List<ServerFileCandidate>();
			foreach (ServerFileCandidate item in discovered)
			{
				if (!previousByKey.TryGetValue(MediaKey(role, item.Blob.Record.Name), out ServerFileCandidate _))
				{
					list2.Add(item);
				}
				else
				{
					list.Add(item);
				}
			}
			int pngCount = 0;
			int gifCount = 0;
			int gifFrameCount = 0;
			Dictionary<string, ServerFileCandidate> accepted = new Dictionary<string, ServerFileCandidate>(StringComparer.Ordinal);
			foreach (ServerFileCandidate item2 in list.OrderBy<ServerFileCandidate, string>((ServerFileCandidate item) => item.Blob.Record.Name, StringComparer.Ordinal))
			{
				ServerFileCandidate candidate = previousByKey[MediaKey(role, item2.Blob.Record.Name)];
				TryAccept(candidate);
			}
			foreach (ServerFileCandidate item3 in list.OrderBy(delegate(ServerFileCandidate item)
			{
				ServerFileCandidate candidate2 = previousByKey[MediaKey(role, item.Blob.Record.Name)];
				return GifSlotCost(item) - GifSlotCost(candidate2);
			}).ThenBy(delegate(ServerFileCandidate item)
			{
				ServerFileCandidate candidate2 = previousByKey[MediaKey(role, item.Blob.Record.Name)];
				return GifFrameCost(item) - GifFrameCost(candidate2);
			}).ThenBy<ServerFileCandidate, string>((ServerFileCandidate item) => item.Blob.Record.Name, StringComparer.Ordinal))
			{
				ServerEmojiBlob blob = item3.Blob;
				ServerFileCandidate serverFileCandidate = previousByKey[MediaKey(role, blob.Record.Name)];
				if (IsSameContent(item3, serverFileCandidate) && accepted.ContainsKey(blob.Record.Name))
				{
					accepted[blob.Record.Name] = item3;
					continue;
				}
				if (accepted.TryGetValue(blob.Record.Name, out ServerFileCandidate value2))
				{
					RemoveAccepted(value2);
				}
				if (!TryAccept(item3))
				{
					string text = DescribeLimit(item3);
					if (TryAccept(serverFileCandidate))
					{
						warnings.Add("Rejected " + label + " update for '" + blob.Record.Name + blob.Record.Extension + "': " + text + "; keeping the previous valid version.");
					}
					else
					{
						warnings.Add("Skipped " + label + " file '" + blob.Record.Name + blob.Record.Extension + "': " + text + ".");
					}
				}
			}
			foreach (ServerFileCandidate item4 in list2.OrderBy<ServerFileCandidate, string>((ServerFileCandidate item) => item.Blob.Record.Name, StringComparer.Ordinal))
			{
				if (!TryAccept(item4))
				{
					ServerEmojiBlob blob2 = item4.Blob;
					warnings.Add("Skipped " + label + " file '" + blob2.Record.Name + blob2.Record.Extension + "': " + DescribeLimit(item4) + ".");
				}
			}
			foreach (ServerFileCandidate item5 in accepted.Values.OrderBy<ServerFileCandidate, string>((ServerFileCandidate item) => item.Blob.Record.Name, StringComparer.Ordinal))
			{
				ServerEmojiBlob blob3 = item5.Blob;
				records.Add(blob3.Record);
				blobs.Add(blob3);
				if (item5.Stamp != null)
				{
					fileStamps[MediaKey(role, blob3.Record.Name)] = item5.Stamp;
				}
			}
			string DescribeLimit(ServerFileCandidate serverFileCandidate2)
			{
				ServerEmojiBlob blob4 = serverFileCandidate2.Blob;
				if (accepted.Count >= maximumTotalFiles)
				{
					return $"at most {maximumTotalFiles} total {label} files are supported";
				}
				if (blob4.Record.Kind == EmojiFileKind.Png)
				{
					if (pngCount < maximumPngFiles)
					{
						return "the file could not be admitted to the resolved catalog";
					}
					return $"at most {maximumPngFiles} PNG files are supported";
				}
				if (gifCount >= maximumGifFiles)
				{
					return $"at most {maximumGifFiles} GIF files are supported";
				}
				if (blob4.GifFrameCount <= 0)
				{
					return "the validated GIF frame count is unavailable";
				}
				if (blob4.GifFrameCount > 3000 - gifFrameCount)
				{
					return $"the catalog would exceed its {3000} total GIF frame budget";
				}
				return "the file could not be admitted to the resolved catalog";
			}
			static int GifFrameCost(ServerFileCandidate serverFileCandidate2)
			{
				if (serverFileCandidate2.Blob.Record.Kind != EmojiFileKind.Gif)
				{
					return 0;
				}
				return serverFileCandidate2.Blob.GifFrameCount;
			}
			static int GifSlotCost(ServerFileCandidate serverFileCandidate2)
			{
				return (serverFileCandidate2.Blob.Record.Kind == EmojiFileKind.Gif) ? 1 : 0;
			}
			static bool IsSameContent(ServerFileCandidate first, ServerFileCandidate second)
			{
				if (first.Blob.Record.Kind == second.Blob.Record.Kind && first.Blob.Record.Length == second.Blob.Record.Length && StringComparer.Ordinal.Equals(first.Blob.Record.Hash, second.Blob.Record.Hash))
				{
					return first.Blob.GifFrameCount == second.Blob.GifFrameCount;
				}
				return false;
			}
			void RemoveAccepted(ServerFileCandidate serverFileCandidate2)
			{
				ServerEmojiBlob blob4 = serverFileCandidate2.Blob;
				if (!accepted.Remove(blob4.Record.Name))
				{
					throw new InvalidOperationException("Clan " + label + " selection lost '" + blob4.Record.Name + "'.");
				}
				if (blob4.Record.Kind == EmojiFileKind.Png)
				{
					pngCount--;
				}
				else
				{
					gifCount--;
					gifFrameCount -= blob4.GifFrameCount;
				}
			}
			bool TryAccept(ServerFileCandidate serverFileCandidate2)
			{
				if (accepted.Count >= maximumTotalFiles)
				{
					return false;
				}
				ServerEmojiBlob blob4 = serverFileCandidate2.Blob;
				if (blob4.Record.Kind == EmojiFileKind.Png)
				{
					if (pngCount >= maximumPngFiles)
					{
						return false;
					}
					pngCount++;
				}
				else
				{
					int gifFrameCount2 = blob4.GifFrameCount;
					if (gifCount >= maximumGifFiles || gifFrameCount2 <= 0 || gifFrameCount2 > 3000 - gifFrameCount)
					{
						return false;
					}
					gifCount++;
					gifFrameCount += gifFrameCount2;
				}
				accepted.Add(blob4.Record.Name, serverFileCandidate2);
				return true;
			}
		}

		private static int GetMaximumSourceBytes(EmojiFileKind kind)
		{
			if (kind != EmojiFileKind.Gif)
			{
				return 524288;
			}
			return 2097152;
		}

		private static string MediaKey(MediaRole role, string name)
		{
			int num = (int)role;
			return num.ToString(CultureInfo.InvariantCulture) + "|" + name;
		}

		private static byte[] ReadStableFile(string path, long expectedLength)
		{
			using FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
			if (fileStream.Length != expectedLength)
			{
				throw new IOException("Media file '" + Path.GetFileName(path) + "' changed while it was being scanned.");
			}
			byte[] array = new byte[fileStream.Length];
			int num;
			for (int i = 0; i < array.Length; i += num)
			{
				num = fileStream.Read(array, i, array.Length - i);
				if (num <= 0)
				{
					throw new EndOfStreamException("Media file '" + Path.GetFileName(path) + "' ended before its declared length.");
				}
			}
			if (fileStream.Length != expectedLength)
			{
				throw new IOException("Media file '" + Path.GetFileName(path) + "' changed while it was being scanned.");
			}
			return array;
		}

		private static string SerializeManifest(IReadOnlyList<ManifestRecord> records)
		{
			if (records.Count == 0)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder("v4");
			foreach (ManifestRecord item in records.OrderBy((ManifestRecord record) => record.Role).ThenBy<ManifestRecord, string>((ManifestRecord record) => record.Name, StringComparer.Ordinal))
			{
				StringBuilder stringBuilder2 = stringBuilder.Append('\n').Append((item.Role == MediaRole.Emoji) ? 'e' : 'm').Append('|')
					.Append((item.Kind == EmojiFileKind.Png) ? 'p' : 'g')
					.Append('|')
					.Append(item.Name)
					.Append('|');
				int length = item.Length;
				stringBuilder2.Append(length.ToString(CultureInfo.InvariantCulture)).Append('|').Append(item.Hash);
			}
			if (stringBuilder.Length > 24576)
			{
				throw new InvalidDataException("Clan media manifest exceeds its supported size.");
			}
			return stringBuilder.ToString();
		}

		private static List<ManifestRecord> ParseManifest(string manifest)
		{
			if (string.IsNullOrEmpty(manifest))
			{
				return new List<ManifestRecord>();
			}
			if (manifest.Length > 24576 || manifest.IndexOf('\r') >= 0)
			{
				throw new InvalidDataException("Clan media manifest is too large or is not canonical.");
			}
			string[] array = manifest.Split(new char[1] { '\n' });
			if (array.Length == 0 || !StringComparer.Ordinal.Equals(array[0], "v4"))
			{
				throw new InvalidDataException("Clan media manifest has an unsupported version.");
			}
			List<ManifestRecord> list = new List<ManifestRecord>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			MediaRole mediaRole = MediaRole.Emoji;
			string x = "";
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			for (int i = 1; i < array.Length; i++)
			{
				string obj = array[i];
				if (obj.Length == 0)
				{
					throw new InvalidDataException("Clan media manifest contains an empty record.");
				}
				string[] array2 = obj.Split(new char[1] { '|' });
				if (array2.Length != 5)
				{
					throw new InvalidDataException("Clan media manifest record has an invalid field count.");
				}
				string text = array2[0];
				MediaRole mediaRole2;
				if (!(text == "e"))
				{
					if (!(text == "m"))
					{
						throw new InvalidDataException("Clan media manifest contains an unknown role.");
					}
					mediaRole2 = MediaRole.Emblem;
				}
				else
				{
					mediaRole2 = MediaRole.Emoji;
				}
				MediaRole mediaRole3 = mediaRole2;
				text = array2[1];
				EmojiFileKind emojiFileKind;
				if (!(text == "p"))
				{
					if (!(text == "g"))
					{
						throw new InvalidDataException("Clan media manifest contains an unknown file type.");
					}
					emojiFileKind = EmojiFileKind.Gif;
				}
				else
				{
					emojiFileKind = EmojiFileKind.Png;
				}
				EmojiFileKind emojiFileKind2 = emojiFileKind;
				if (mediaRole3 == MediaRole.Emblem && emojiFileKind2 != EmojiFileKind.Png)
				{
					throw new InvalidDataException("Clan media manifest contains a non-PNG emblem.");
				}
				string text2 = array2[2];
				string item = array2[0] + "|" + text2;
				if (!IsSafeName(text2) || !hashSet.Add(item))
				{
					throw new InvalidDataException("Clan media manifest contains an invalid or duplicate name.");
				}
				if (list.Count > 0 && (mediaRole3 < mediaRole || (mediaRole3 == mediaRole && StringComparer.Ordinal.Compare(x, text2) >= 0)))
				{
					throw new InvalidDataException("Clan media manifest records are not strictly sorted.");
				}
				mediaRole = mediaRole3;
				x = text2;
				if (!int.TryParse(array2[3], NumberStyles.None, CultureInfo.InvariantCulture, out var result) || result <= 0 || result > GetMaximumSourceBytes(emojiFileKind2) || !StringComparer.Ordinal.Equals(array2[3], result.ToString(CultureInfo.InvariantCulture)))
				{
					throw new InvalidDataException("Clan media manifest contains an invalid file length.");
				}
				if (!IsSha256(array2[4]))
				{
					throw new InvalidDataException("Clan media manifest contains an invalid SHA-256 hash.");
				}
				if (mediaRole3 == MediaRole.Emblem)
				{
					num3++;
				}
				else if (emojiFileKind2 == EmojiFileKind.Png)
				{
					num++;
				}
				else
				{
					num2++;
				}
				list.Add(new ManifestRecord(mediaRole3, emojiFileKind2, text2, result, array2[4]));
			}
			if (num > 100 || num2 > 50 || num + num2 > 100 || num3 > 50)
			{
				throw new InvalidDataException("Clan media manifest contains too many files.");
			}
			if (!StringComparer.Ordinal.Equals(manifest, SerializeManifest(list)))
			{
				throw new InvalidDataException("Clan media manifest is not in canonical form.");
			}
			return list;
		}

		private static void OnSyncedManifestChanged()
		{
			ZNet instance = ZNet.instance;
			if (_initialized && !GUIManager.IsHeadless() && !((Object)(object)instance == (Object)null) && !instance.IsServer())
			{
				QueueManifest(SyncedManifest.Value);
			}
		}

		private static void QueueManifest(string manifest)
		{
			_pendingManifest = new PendingManifestState(manifest, ZNet.instance);
		}

		private static void StartBuild(string manifest)
		{
			CancelBuild();
			_waitingManifest = "";
			_waitingRecords = null;
			CancelEmojiClientCatalog();
			try
			{
				List<ManifestRecord> list = ParseManifest(manifest);
				if (list.Count == 0)
				{
					ReplaceRuntime(null);
					_preparedSources.Clear();
					_activeManifest = "";
					_activeRecords = Array.Empty<ManifestRecord>();
				}
				else if (!StringComparer.Ordinal.Equals(_activeManifest, manifest) || _runtime == null)
				{
					_waitingManifest = manifest;
					_waitingRecords = list;
					BeginEmojiClientCatalog(manifest, list);
				}
			}
			catch (Exception ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Synchronized Clan media manifest was rejected: " + ex.Message));
			}
		}

		private static void StartReadyEmojiBuild()
		{
			if (_waitingRecords != null && IsEmojiClientCatalogReady(_waitingManifest))
			{
				_build = new BuildState(_waitingManifest, _waitingRecords, ZNet.instance);
				_waitingManifest = "";
				_waitingRecords = null;
			}
		}

		private static void CancelBuild()
		{
			BuildState? build = _build;
			_build = null;
			build?.Cancel();
		}

		private static void ProcessBuildStep()
		{
			BuildState build = _build;
			if (build == null)
			{
				return;
			}
			if (build.Session != ZNet.instance)
			{
				CancelBuild();
				return;
			}
			if (build.PendingGifTask != null)
			{
				if (!build.PendingGifTask.IsCompleted)
				{
					return;
				}
				ManifestRecord pendingGifRecord = build.PendingGifRecord;
				Task<SourceEmoji> pendingGifTask = build.PendingGifTask;
				build.PendingGifRecord = null;
				build.PendingGifTask = null;
				try
				{
					AddBuildSource(build, pendingGifTask.GetAwaiter().GetResult());
					return;
				}
				catch (Exception error)
				{
					RecordBuildFailure(build, pendingGifRecord, error);
					return;
				}
			}
			if (build.NextRecordIndex < build.Records.Count)
			{
				ManifestRecord record = build.Records[build.NextRecordIndex++];
				if (build.PreparedSources.TryGetValue(SourceCacheKey(record), out SourceEmoji value))
				{
					AddBuildSource(build, value.WithRecord(record));
					return;
				}
				if (record.Kind == EmojiFileKind.Gif)
				{
					try
					{
						byte[] data = ReadSyncedEmojiFile(record);
						build.PendingGifRecord = record;
						CancellationToken cancellationToken = build.Cancellation.Token;
						build.PendingGifTask = Task.Run(() => LoadGifSourceSerialized(record, data, cancellationToken), cancellationToken);
						build.PendingGifTask.ContinueWith((Task<SourceEmoji> completed) => completed.Exception, TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously);
						return;
					}
					catch (Exception error2)
					{
						RecordBuildFailure(build, record, error2);
						return;
					}
				}
				try
				{
					byte[] data2 = ReadSyncedEmojiFile(record);
					SourceEmoji source = LoadPngSource(record, data2);
					AddBuildSource(build, source);
					return;
				}
				catch (Exception error3)
				{
					RecordBuildFailure(build, record, error3);
					return;
				}
			}
			if (build.Failures > 0 || build.Sources.Count + build.GifFrameBudgetSkips != build.Records.Count)
			{
				CancelBuild();
				ClanPlugin.ClanLogger.LogWarning((object)($"Clan media update was not applied because {build.Failures} synchronized files failed validation. " + "The previous media set remains active."));
				return;
			}
			if (build.Sources.Count == 0)
			{
				CancelBuild();
				ClanPlugin.ClanLogger.LogWarning((object)"Clan media update contained no files within the client GIF frame budget. The previous media set remains active.");
				return;
			}
			if (build.RuntimeBuild == null)
			{
				try
				{
					build.RuntimeBuild = new RuntimeBuildState(build.Manifest, build.Sources);
					return;
				}
				catch (Exception ex)
				{
					CancelBuild();
					ClanPlugin.ClanLogger.LogWarning((object)("Clan media runtime could not be prepared; the previous set remains active: " + ex.Message));
					return;
				}
			}
			try
			{
				RuntimeLibrary runtimeLibrary = ProcessRuntimeBuildStep(build.RuntimeBuild);
				if (runtimeLibrary == null)
				{
					return;
				}
				Dictionary<string, SourceEmoji> preparedSources = build.Sources.GroupBy<SourceEmoji, string>((SourceEmoji sourceEmoji) => SourceCacheKey(sourceEmoji.Record), StringComparer.Ordinal).ToDictionary<IGrouping<string, SourceEmoji>, string, SourceEmoji>((IGrouping<string, SourceEmoji> group) => group.Key, (IGrouping<string, SourceEmoji> group) => group.First(), StringComparer.Ordinal);
				build.RuntimeBuild.ReleaseOwnership();
				try
				{
					ReplaceRuntime(runtimeLibrary);
				}
				catch
				{
					if (_runtime != runtimeLibrary)
					{
						DestroyRuntime(runtimeLibrary);
					}
					throw;
				}
				_build = null;
				_activeManifest = build.Manifest;
				_activeRecords = build.Records;
				_preparedSources = preparedSources;
				PruneEmojiCache(build.Records);
				ClanPlugin.ClanLogger.LogInfo((object)($"Applied {build.Sources.Count} synchronized Clan media files" + ((build.GifFrameBudgetSkips == 0) ? "." : ($"; skipped {build.GifFrameBudgetSkips} GIF file(s) outside the " + $"{3000}-frame client budget."))));
			}
			catch (Exception ex2)
			{
				CancelBuild();
				ClanPlugin.ClanLogger.LogWarning((object)("Clan media runtime could not be built; the previous set remains active: " + ex2.Message));
			}
		}

		private static void AddBuildSource(BuildState build, SourceEmoji source)
		{
			if (source.Record.Kind == EmojiFileKind.Gif)
			{
				int count = source.Frames.Count;
				if (count > 3000 - build.TotalGifFrames)
				{
					build.GifFrameBudgetSkips++;
					ClanPlugin.ClanLogger.LogWarning((object)("Clan emoji '" + source.Record.Name + source.Record.Extension + "' was skipped on this client: " + $"the synchronized catalog would exceed its {3000} total GIF frame budget."));
					return;
				}
				build.TotalGifFrames += count;
			}
			build.Sources.Add(source);
			build.PreparedSources[SourceCacheKey(source.Record)] = source;
		}

		private static SourceEmoji LoadGifSourceSerialized(ManifestRecord record, byte[] data, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			GifDecodeGate.Wait(cancellationToken);
			try
			{
				cancellationToken.ThrowIfCancellationRequested();
				SourceEmoji result = LoadGifSource(record, data);
				cancellationToken.ThrowIfCancellationRequested();
				return result;
			}
			finally
			{
				GifDecodeGate.Release();
			}
		}

		private static void RecordBuildFailure(BuildState build, ManifestRecord record, Exception error)
		{
			build.Failures++;
			ClanPlugin.ClanLogger.LogWarning((object)("Clan " + ((record.Role == MediaRole.Emoji) ? "emoji" : "emblem") + " '" + record.Name + "' is unavailable on this client: " + error.Message));
		}

		private static string SourceCacheKey(ManifestRecord record)
		{
			return record.Kind.ToString() + ":" + record.Hash;
		}

		private static SourceEmoji LoadPngSource(ManifestRecord record, byte[] data)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			ValidatePngHeader(data, out var width, out var height);
			Texture2D val = null;
			try
			{
				val = new Texture2D(2, 2, (TextureFormat)4, false)
				{
					name = "Clan Emoji Source " + record.Name,
					hideFlags = (HideFlags)61,
					wrapMode = (TextureWrapMode)1,
					filterMode = (FilterMode)1,
					anisoLevel = 0
				};
				if (!AssetUtils.LoadImage(val, data))
				{
					throw new InvalidDataException("Unity could not decode the PNG.");
				}
				if (((Texture)val).width != width || ((Texture)val).height != height)
				{
					throw new InvalidDataException("Decoded PNG dimensions do not match its header.");
				}
				ResizeToRenderedBounds(GetTopDownRgba(val), ((Texture)val).width, ((Texture)val).height, out byte[] rendered, out int renderedWidth, out int renderedHeight);
				return new SourceEmoji(record, renderedWidth, renderedHeight, new List<byte[]> { rendered }, 0);
			}
			finally
			{
				SafeDestroy((Object?)(object)val);
			}
		}

		private static SourceEmoji LoadGifSource(ManifestRecord record, byte[] data)
		{
			ClanGifDecoder.Animation animation = ClanGifDecoder.Decode(data, 2097152, 512, 180, 8388608L);
			long num = ValidateGifAnimation(animation);
			int count = animation.Frames.Count;
			int framesPerSecond = ((count != 1) ? Clamp((int)Math.Round((double)count * 1000.0 / (double)num, MidpointRounding.AwayFromZero), 1, 50) : 0);
			List<byte[]> list = new List<byte[]>(count);
			int renderedWidth = 0;
			int renderedHeight = 0;
			foreach (ClanGifDecoder.Frame frame in animation.Frames)
			{
				ResizeToRenderedBounds(frame.Rgba32, animation.Width, animation.Height, out byte[] rendered, out renderedWidth, out renderedHeight);
				list.Add(rendered);
			}
			return new SourceEmoji(record, renderedWidth, renderedHeight, list, framesPerSecond);
		}

		private static long ValidateGifAnimation(ClanGifDecoder.Animation animation)
		{
			if (animation.Frames.Count == 0)
			{
				throw new InvalidDataException("GIF does not contain an image frame.");
			}
			if (animation.Frames.Any((ClanGifDecoder.Frame frame) => frame.RequiresUserInput))
			{
				throw new InvalidDataException("GIF frames requiring user input are not supported.");
			}
			if (animation.Frames.Count > 1 && !animation.LoopsForever)
			{
				throw new InvalidDataException("Animated GIF must declare infinite looping.");
			}
			long num = animation.Frames.Aggregate(0L, (long current, ClanGifDecoder.Frame frame) => current + Math.Max(20, frame.DelayMilliseconds));
			if (num <= 0 || num > 10000)
			{
				throw new InvalidDataException($"GIF duration must be between 1 and {10000L} milliseconds.");
			}
			return num;
		}

		private static void ResizeToRenderedBounds(byte[] source, int sourceWidth, int sourceHeight, out byte[] rendered, out int renderedWidth, out int renderedHeight)
		{
			float num = 96f / (float)Math.Max(sourceWidth, sourceHeight);
			renderedWidth = Math.Max(1, RoundPositive((float)sourceWidth * num));
			renderedHeight = Math.Max(1, RoundPositive((float)sourceHeight * num));
			rendered = ((renderedWidth == sourceWidth && renderedHeight == sourceHeight) ? source : ResizeRgbaBilinear(source, sourceWidth, sourceHeight, renderedWidth, renderedHeight));
		}

		private static byte[] GetTopDownRgba(Texture2D texture)
		{
			//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_0055: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			Color32[] pixels = texture.GetPixels32();
			byte[] array = new byte[checked(((Texture)texture).width * ((Texture)texture).height * 4)];
			for (int i = 0; i < ((Texture)texture).height; i++)
			{
				int num = ((Texture)texture).height - 1 - i;
				for (int j = 0; j < ((Texture)texture).width; j++)
				{
					Color32 val = pixels[num * ((Texture)texture).width + j];
					int num2 = (i * ((Texture)texture).width + j) * 4;
					array[num2] = val.r;
					array[num2 + 1] = val.g;
					array[num2 + 2] = val.b;
					array[num2 + 3] = val.a;
				}
			}
			return array;
		}

		private static byte[] ResizeRgbaBilinear(byte[] source, int sourceWidth, int sourceHeight, int targetWidth, int targetHeight)
		{
			byte[] array = new byte[checked(targetWidth * targetHeight * 4)];
			float num = (float)sourceWidth / (float)targetWidth;
			float num2 = (float)sourceHeight / (float)targetHeight;
			for (int i = 0; i < targetHeight; i++)
			{
				float num3 = ((float)i + 0.5f) * num2 - 0.5f;
				int num4 = Clamp((int)Math.Floor(num3), 0, sourceHeight - 1);
				int num5 = Math.Min(num4 + 1, sourceHeight - 1);
				float num6 = Clamp01(num3 - (float)num4);
				for (int j = 0; j < targetWidth; j++)
				{
					float num7 = ((float)j + 0.5f) * num - 0.5f;
					int num8 = Clamp((int)Math.Floor(num7), 0, sourceWidth - 1);
					int num9 = Math.Min(num8 + 1, sourceWidth - 1);
					float num10 = Clamp01(num7 - (float)num8);
					int num11 = (num4 * sourceWidth + num8) * 4;
					int num12 = (num4 * sourceWidth + num9) * 4;
					int num13 = (num5 * sourceWidth + num8) * 4;
					int num14 = (num5 * sourceWidth + num9) * 4;
					int num15 = (i * targetWidth + j) * 4;
					float num16 = (1f - num10) * (1f - num6);
					float num17 = num10 * (1f - num6);
					float num18 = (1f - num10) * num6;
					float num19 = num10 * num6;
					float num20 = (float)(int)source[num11 + 3] * num16 + (float)(int)source[num12 + 3] * num17 + (float)(int)source[num13 + 3] * num18 + (float)(int)source[num14 + 3] * num19;
					array[num15 + 3] = (byte)Clamp(RoundPositive(num20), 0, 255);
					if (num20 <= 0.001f)
					{
						array[num15] = 0;
						array[num15 + 1] = 0;
						array[num15 + 2] = 0;
						continue;
					}
					for (int k = 0; k < 3; k++)
					{
						float num21 = (float)(source[num11 + k] * source[num11 + 3]) * num16 + (float)(source[num12 + k] * source[num12 + 3]) * num17 + (float)(source[num13 + k] * source[num13 + 3]) * num18 + (float)(source[num14 + k] * source[num14 + 3]) * num19;
						array[num15 + k] = (byte)Clamp(RoundPositive(num21 / num20), 0, 255);
					}
				}
			}
			return array;
		}

		private static int RoundPositive(float value)
		{
			return (int)Math.Floor(value + 0.5f);
		}

		private static int Clamp(int value, int minimum, int maximum)
		{
			if (value >= minimum)
			{
				if (value <= maximum)
				{
					return value;
				}
				return maximum;
			}
			return minimum;
		}

		private static float Clamp01(float value)
		{
			if (!(value < 0f))
			{
				if (!(value > 1f))
				{
					return value;
				}
				return 1f;
			}
			return 0f;
		}

		private static RuntimeLibrary? ProcessRuntimeBuildStep(RuntimeBuildState build)
		{
			switch (build.Stage)
			{
			case RuntimeBuildStage.StaticEmoji:
				BuildStaticEmojiSheet(build);
				build.Stage = RuntimeBuildStage.AnimatedEmoji;
				return null;
			case RuntimeBuildStage.AnimatedEmoji:
				if (build.NextAnimatedSourceIndex < build.AnimatedSources.Count)
				{
					BuildAnimatedEmojiSheet(build, build.AnimatedSources[build.NextAnimatedSourceIndex++]);
				}
				if (build.NextAnimatedSourceIndex >= build.AnimatedSources.Count)
				{
					build.Stage = RuntimeBuildStage.Emblems;
				}
				return null;
			case RuntimeBuildStage.Emblems:
				BuildEmblemSheet(build);
				build.Stage = RuntimeBuildStage.Finalize;
				return null;
			case RuntimeBuildStage.Finalize:
			{
				RuntimeLibrary result = FinalizeRuntimeLibrary(build);
				build.Stage = RuntimeBuildStage.Completed;
				return result;
			}
			default:
				throw new InvalidOperationException("Clan media runtime build is already complete.");
			}
		}

		private static void BuildStaticEmojiSheet(RuntimeBuildState build)
		{
			if (build.StillSources.Count != 0)
			{
				List<FrameSpec> frames = build.StillSources.Select((SourceEmoji source) => new FrameSpec(source, 0, SpriteName(source.Record, 0, animated: false))).ToList();
				RuntimeSheet sheet = BuildRuntimeSheet("ClanEmoji_Still_" + build.ManifestHash, frames);
				TrackRuntimeSheet(build, sheet, isEmoji: true);
				for (int num = 0; num < build.StillSources.Count; num++)
				{
					build.References[build.StillSources[num]] = new SourceRuntimeReference(sheet, num);
				}
			}
		}

		private static void BuildAnimatedEmojiSheet(RuntimeBuildState build, SourceEmoji source)
		{
			List<FrameSpec> frames = (from index in Enumerable.Range(0, source.Frames.Count)
				select new FrameSpec(source, index, SpriteName(source.Record, index, animated: true))).ToList();
			RuntimeSheet sheet = BuildRuntimeSheet("ClanEmoji_" + source.Record.Name + "_" + source.Record.Hash.Substring(0, 12), frames);
			TrackRuntimeSheet(build, sheet, isEmoji: true);
			build.References[source] = new SourceRuntimeReference(sheet, 0);
		}

		private static void BuildEmblemSheet(RuntimeBuildState build)
		{
			if (build.EmblemSources.Count != 0)
			{
				List<FrameSpec> frames = build.EmblemSources.Select((SourceEmoji source) => new FrameSpec(source, 0, SpriteName(source.Record, 0, animated: false))).ToList();
				RuntimeSheet sheet = BuildRuntimeSheet("ClanEmblem_Still_" + build.ManifestHash, frames);
				TrackRuntimeSheet(build, sheet, isEmoji: false);
				for (int num = 0; num < build.EmblemSources.Count; num++)
				{
					build.References[build.EmblemSources[num]] = new SourceRuntimeReference(sheet, num);
				}
			}
		}

		private static void TrackRuntimeSheet(RuntimeBuildState build, RuntimeSheet sheet, bool isEmoji)
		{
			try
			{
				build.Sheets.Add(sheet);
				if (isEmoji)
				{
					build.EmojiSheets.Add(sheet);
				}
			}
			catch
			{
				build.EmojiSheets.Remove(sheet);
				build.Sheets.Remove(sheet);
				DestroyRuntimeSheet(sheet);
				throw;
			}
		}

		private static RuntimeLibrary FinalizeRuntimeLibrary(RuntimeBuildState build)
		{
			List<RuntimeSheet> sheets = build.Sheets;
			List<RuntimeSheet> emojiSheets = build.EmojiSheets;
			Dictionary<SourceEmoji, SourceRuntimeReference> references = build.References;
			IReadOnlyList<SourceEmoji> emojiSources = build.EmojiSources;
			IReadOnlyList<SourceEmoji> emblemSources = build.EmblemSources;
			if (sheets.Count == 0)
			{
				throw new InvalidOperationException("No Clan media sprite sheets were produced.");
			}
			TMP_SpriteAsset val = ((emojiSheets.Count == 0) ? null : emojiSheets[0].SpriteAsset);
			if ((Object)(object)val != (Object)null)
			{
				TMP_SpriteAsset val2 = val;
				if (val2.fallbackSpriteAssets == null)
				{
					val2.fallbackSpriteAssets = new List<TMP_SpriteAsset>();
				}
				for (int i = 1; i < emojiSheets.Count; i++)
				{
					val.fallbackSpriteAssets.Add(emojiSheets[i].SpriteAsset);
				}
			}
			List<RuntimeEmoji> list = new List<RuntimeEmoji>();
			Dictionary<string, RuntimeRenderTag> dictionary = new Dictionary<string, RuntimeRenderTag>(StringComparer.OrdinalIgnoreCase);
			Dictionary<string, RuntimeRenderTag> dictionary2 = new Dictionary<string, RuntimeRenderTag>(StringComparer.OrdinalIgnoreCase);
			foreach (SourceEmoji item in emojiSources)
			{
				SourceRuntimeReference sourceRuntimeReference = references[item];
				Sprite val3 = sourceRuntimeReference.Sheet.Sprites[sourceRuntimeReference.FirstFrameIndex];
				string name = ((Object)val3).name;
				string text = "<sprite name=\"" + name + "\">";
				string animatedTag = ((item.Frames.Count == 1) ? text : $"<sprite name=\"{name}\" anim=\"0,{item.Frames.Count - 1},{item.FramesPerSecond}\">");
				string text2 = TokenForName(item.Record.Name);
				list.Add(new RuntimeEmoji(text2, val3, item.Record.Kind == EmojiFileKind.Gif));
				RuntimeRenderTag value = (dictionary[text2] = new RuntimeRenderTag(animatedTag, text, item.Frames.Count > 1));
				dictionary2[name] = value;
			}
			Regex tokenRegex = ((list.Count == 0) ? new Regex("(?!)", RegexOptions.Compiled | RegexOptions.CultureInvariant) : new Regex(string.Join("|", (from entry in list
				select entry.Token into token
				orderby token.Length descending
				select token).Select(Regex.Escape)), RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.CultureInvariant));
			Regex spriteTagRegex = ((dictionary2.Count == 0) ? new Regex("(?!)", RegexOptions.Compiled | RegexOptions.CultureInvariant) : new Regex("<sprite\\s+name=\"(?<name>" + string.Join("|", dictionary2.Keys.OrderByDescending((string text3) => text3.Length).Select(Regex.Escape)) + ")\"(?:\\s+anim=\"[^\"]*\")?\\s*/?>", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.CultureInvariant));
			List<ClanEmblemPickerItem> list2 = emblemSources.Select(delegate(SourceEmoji source)
			{
				SourceRuntimeReference sourceRuntimeReference2 = references[source];
				return new ClanEmblemPickerItem(source.Record.Name, sourceRuntimeReference2.Sheet.Sprites[sourceRuntimeReference2.FirstFrameIndex]);
			}).ToList();
			Dictionary<string, ClanEmblemPickerItem> emblemsByName = list2.ToDictionary<ClanEmblemPickerItem, string>((ClanEmblemPickerItem entry) => entry.Name, StringComparer.Ordinal);
			return new RuntimeLibrary(val, sheets.ToArray(), list, list2.AsReadOnly(), emblemsByName, dictionary, tokenRegex, dictionary2, spriteTagRegex);
		}

		private static RuntimeSheet BuildRuntimeSheet(string assetName, IReadOnlyList<FrameSpec> frames)
		{
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: 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_01ce: 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_01dd: 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_01ed: Expected O, but got Unknown
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Expected O, but got Unknown
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			//IL_044c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Expected O, but got Unknown
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0477: Unknown result type (might be due to invalid IL or missing references)
			//IL_0484: Expected O, but got Unknown
			if (frames.Count == 0)
			{
				throw new ArgumentException("A sprite sheet requires at least one frame.", "frames");
			}
			if (SpriteAssetVersionField == null)
			{
				throw new MissingFieldException(typeof(TMP_Asset).FullName, "m_Version");
			}
			int num = frames.Max((FrameSpec frame) => frame.Source.Width);
			int num2 = frames.Max((FrameSpec frame) => frame.Source.Height);
			int num3 = Math.Min(5, Math.Max(1, (int)Math.Ceiling(Math.Sqrt(frames.Count))));
			int num4 = (frames.Count + num3 - 1) / num3;
			int num5 = num + 4;
			int num6 = num2 + 4;
			int num7;
			int num8;
			byte[] array;
			GlyphRect[] array2;
			checked
			{
				num7 = num3 * num5;
				num8 = num4 * num6;
				array = new byte[num7 * num8 * 4];
				array2 = (GlyphRect[])(object)new GlyphRect[frames.Count];
			}
			for (int num9 = 0; num9 < frames.Count; num9++)
			{
				FrameSpec frameSpec = frames[num9];
				int num10 = num9 % num3;
				int num11 = num9 / num3;
				int num12 = num10 * num5 + 2 + (num - frameSpec.Source.Width) / 2;
				int num13 = num8 - (num11 + 1) * num6 + 2 + (num2 - frameSpec.Source.Height) / 2;
				BlitWithGutter(frameSpec.Pixels, frameSpec.Source.Width, frameSpec.Source.Height, array, num7, num8, num12, num13, 2);
				array2[num9] = new GlyphRect(num12, num13, frameSpec.Source.Width, frameSpec.Source.Height);
			}
			Texture2D val = null;
			TMP_SpriteAsset val2 = null;
			Material val3 = null;
			Sprite[] array3 = Array.Empty<Sprite>();
			try
			{
				val = new Texture2D(num7, num8, (TextureFormat)4, false)
				{
					name = assetName + " Texture",
					hideFlags = (HideFlags)61,
					wrapMode = (TextureWrapMode)1,
					filterMode = (FilterMode)1,
					anisoLevel = 0
				};
				val.LoadRawTextureData(array);
				val.Apply(false, true);
				val2 = ScriptableObject.CreateInstance<TMP_SpriteAsset>();
				((Object)val2).name = assetName;
				((Object)val2).hideFlags = (HideFlags)61;
				SpriteAssetVersionField.SetValue(val2, "1.1.0");
				val2.spriteSheet = (Texture)(object)val;
				val2.spriteInfoList = new List<TMP_Sprite>();
				val2.fallbackSpriteAssets = new List<TMP_SpriteAsset>();
				((TMP_Asset)val2).hashCode = TMP_TextUtilities.GetSimpleHashCode(assetName);
				TMP_SpriteAsset obj = val2;
				FaceInfo faceInfo = default(FaceInfo);
				((FaceInfo)(ref faceInfo)).familyName = assetName;
				((FaceInfo)(ref faceInfo)).styleName = "Regular";
				((FaceInfo)(ref faceInfo)).pointSize = 96f;
				((FaceInfo)(ref faceInfo)).scale = 1f;
				((FaceInfo)(ref faceInfo)).lineHeight = 96f;
				((FaceInfo)(ref faceInfo)).ascentLine = 96f;
				((FaceInfo)(ref faceInfo)).capLine = 96f;
				((FaceInfo)(ref faceInfo)).meanLine = 48f;
				((FaceInfo)(ref faceInfo)).baseline = 0f;
				((FaceInfo)(ref faceInfo)).descentLine = 0f;
				((TMP_Asset)obj).faceInfo = faceInfo;
				ShaderUtilities.GetShaderPropertyIDs();
				Shader obj2 = Shader.Find("TextMeshPro/Sprite");
				if ((Object)(object)obj2 == (Object)null)
				{
					throw new InvalidOperationException("TextMeshPro/Sprite shader was not found.");
				}
				val3 = new Material(obj2)
				{
					name = assetName + " Material",
					hideFlags = (HideFlags)61
				};
				val3.SetTexture(ShaderUtilities.ID_MainTex, (Texture)(object)val);
				((TMP_Asset)val2).material = val3;
				((TMP_Asset)val2).materialHashCode = TMP_TextUtilities.GetSimpleHashCode(((Object)val3).name);
				List<TMP_SpriteGlyph> spriteGlyphTable = val2.spriteGlyphTable;
				List<TMP_SpriteCharacter> spriteCharacterTable = val2.spriteCharacterTable;
				spriteGlyphTable.Clear();
				spriteCharacterTable.Clear();
				array3 = (Sprite[])(object)new Sprite[frames.Count];
				Rect val5 = default(Rect);
				GlyphMetrics val7 = default(GlyphMetrics);
				for (int num14 = 0; num14 < frames.Count; num14++)
				{
					FrameSpec frameSpec2 = frames[num14];
					GlyphRect val4 = array2[num14];
					((Rect)(ref val5))..ctor((float)((GlyphRect)(ref val4)).x, (float)((GlyphRect)(ref val4)).y, (float)((GlyphRect)(ref val4)).width, (float)((GlyphRect)(ref val4)).height);
					Sprite val6 = Sprite.Create(val, val5, new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, Vector4.zero, false);
					((Object)val6).name = frameSpec2.SpriteName;
					((Object)val6).hideFlags = (HideFlags)61;
					array3[num14] = val6;
					((GlyphMetrics)(ref val7))..ctor((float)frameSpec2.Source.Width, (float)frameSpec2.Source.Height, 0f, (float)frameSpec2.Source.Height, (float)frameSpec2.Source.Width);
					TMP_SpriteGlyph val8 = new TMP_SpriteGlyph((uint)num14, val7, val4, 1f, 0, val6);
					spriteGlyphTable.Add(val8);
					TMP_SpriteCharacter item = new TMP_SpriteCharacter(65534u, val2, val8)
					{
						name = frameSpec2.SpriteName,
						scale = 1f
					};
					spriteCharacterTable.Add(item);
				}
				val2.UpdateLookupTables();
				return new RuntimeSheet(val, val2, val3, array3);
			}
			catch
			{
				Sprite[] array4 = array3;
				for (int num15 = 0; num15 < array4.Length; num15++)
				{
					SafeDestroy((Object?)(object)array4[num15]);
				}
				SafeDestroy((Object?)(object)val3);
				SafeDestroy((Object?)(object)val2);
				SafeDestroy((Object?)(object)val);
				throw;
			}
		}

		private static void BlitWithGutter(byte[] source, int sourceWidth, int sourceHeight, byte[] atlas, int atlasWidth, int atlasHeight, int contentX, int contentY, int gutter)
		{
			for (int i = -gutter; i < sourceHeight + gutter; i++)
			{
				int num = Mathf.Clamp(i, 0, sourceHeight - 1);
				int num2 = contentY + sourceHeight - 1 - i;
				if (num2 < 0 || num2 >= atlasHeight)
				{
					continue;
				}
				for (int j = -gutter; j < sourceWidth + gutter; j++)
				{
					int num3 = Mathf.Clamp(j, 0, sourceWidth - 1);
					int num4 = contentX + j;
					if (num4 >= 0 && num4 < atlasWidth)
					{
						int num5 = (num * sourceWidth + num3) * 4;
						int num6 = (num2 * atlasWidth + num4) * 4;
						atlas[num6] = source[num5];
						atlas[num6 + 1] = source[num5 + 1];
						atlas[num6 + 2] = source[num5 + 2];
						atlas[num6 + 3] = source[num5 + 3];
					}
				}
			}
		}

		private static void ReplaceRuntime(RuntimeLibrary? next)
		{
			if (_runtime == next)
			{
				return;
			}
			RuntimeLibrary runtime = _runtime;
			DetachOutput();
			_runtime = next;
			try
			{
				try
				{
					EnsureOutputAttachment();
				}
				catch (Exception ex)
				{
					try
					{
						ClanPlugin.ClanLogger.LogWarning((object)("Clan media UI attachment will be retried: " + ex.Message));
					}
					catch
					{
					}
				}
				NotifyChanged();
			}
			finally
			{
				DestroyRuntime(runtime);
			}
		}

		private static void EnsureOutputAttachment()
		{
			if (!ClanVanillaChatDock.SupportsCurrentChatUi)
			{
				DetachOutput();
				return;
			}
			TMP_Text val = (TMP_Text)(object)(((Object)(object)Chat.instance == (Object)null) ? null : ((Terminal)Chat.instance).m_output);
			TMP_SpriteAsset val2 = _runtime?.RootSpriteAsset;
			if ((Object)(object)val2 == (Object)null || (Object)(object)val == (Object)null)
			{
				DetachOutput();
			}
			else
			{
				if ((Object)(object)_attachedOutput == (Object)(object)val && IsRuntimeAttached(val, val2))
				{
					return;
				}
				DetachOutput();
				_attachedOutput = val;
				if ((Object)(object)val.spriteAsset == (Object)null)
				{
					val.spriteAsset = val2;
					_installedAsPrimary = true;
				}
				else if ((Object)(object)val.spriteAsset != (Object)(object)val2)
				{
					TMP_SpriteAsset spriteAsset = val.spriteAsset;
					TMP_SpriteAsset val3 = spriteAsset;
					if (val3.fallbackSpriteAssets == null)
					{
						val3.fallbackSpriteAssets = new List<TMP_SpriteAsset>();
					}
					if (!spriteAsset.fallbackSpriteAssets.Contains(val2))
					{
						spriteAsset.fallbackSpriteAssets.Add(val2);
						_addedFallback = true;
					}
					_fallbackOwner = spriteAsset;
				}
				RefreshOutput(val);
			}
		}

		private static bool IsRuntimeAttached(TMP_Text output, TMP_SpriteAsset root)
		{
			if ((Object)(object)output.spriteAsset == (Object)(object)root)
			{
				return true;
			}
			if ((Object)(object)output.spriteAsset != (Object)null && output.spriteAsset.fallbackSpriteAssets != null)
			{
				return output.spriteAsset.fallbackSpriteAssets.Contains(root);
			}
			return false;
		}

		private static void DetachOutput()
		{
			TMP_Text attachedOutput = _attachedOutput;
			TMP_SpriteAsset val = _runtime?.RootSpriteAsset;
			if ((Object)(object)attachedOutput != (Object)null)
			{
				TMP_SpriteAnimator component = ((Component)attachedOutput).GetComponent<TMP_SpriteAnimator>();
				if (component != null)
				{
					component.StopAllAnimations();
				}
			}
			if (_addedFallback && (Object)(object)_fallbackOwner != (Object)null && (Object)(object)val != (Object)null && _fallbackOwner.fallbackSpriteAssets != null)
			{
				_fallbackOwner.fallbackSpriteAssets.Remove(val);
			}
			if (_installedAsPrimary && (Object)(object)attachedOutput != (Object)null && (Object)(object)val != (Object)null && (Object)(object)attachedOutput.spriteAsset == (Object)(object)val)
			{
				attachedOutput.spriteAsset = null;
			}
			if ((Object)(object)attachedOutput != (Object)null)
			{
				RefreshOutput(attachedOutput);
				TMP_SpriteAnimator component2 = ((Component)attachedOutput).GetComponent<TMP_SpriteAnimator>();
				if (component2 != null)
				{
					component2.StopAllAnimations();
				}
			}
			_fallbackOwner = null;
			_attachedOutput = null;
			_installedAsPrimary = false;
			_addedFallback = false;
		}

		private static void RefreshOutput(TMP_Text output)
		{
			output.havePropertiesChanged = true;
			((Graphic)output).SetVerticesDirty();
			try
			{
				output.ForceMeshUpdate(true, true);
			}
			catch (Exception ex)
			{
				ClanPlugin.ClanLogger.LogDebug((object)("Clan emoji output refresh was deferred: " + ex.Message));
			}
		}

		private static bool ContainsEmojiMarker(string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			if (text.IndexOf(":clan_", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text.IndexOf("clan_emoji_", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static void StopChatOutputAnimationsBeforeRewrite(Terminal terminal)
		{
			TMP_Text output = (TMP_Text)(object)terminal.m_output;
			if ((Object)(object)output != (Object)null && (Object)(object)output == (Object)(object)_attachedOutput)
			{
				TMP_SpriteAnimator component = ((Component)output).GetComponent<TMP_SpriteAnimator>();
				if (component != null)
				{
					component.StopAllAnimations();
				}
			}
		}

		private static void NotifyChanged()
		{
			PublishMediaChanged(ClanEmoji.EmojiChanged, "emoji");
			PublishMediaChanged(ClanEmoji.EmblemsChanged, "emblem");
		}

		private static void PublishMediaChanged(Action? handlers, string mediaKind)
		{
			if (handlers == null)
			{
				return;
			}
			Delegate[] invocationList = handlers.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action action = (Action)invocationList[i];
				try
				{
					action();
				}
				catch (Exception ex)
				{
					ClanPlugin.ClanLogger.LogWarning((object)("Clan " + mediaKind + " UI refresh failed: " + ex.Message));
				}
			}
		}

		private static void DestroyRuntime(RuntimeLibrary? runtime)
		{
			if (runtime == null)
			{
				return;
			}
			runtime.RootSpriteAsset?.fallbackSpriteAssets?.Clear();
			foreach (RuntimeSheet sheet in runtime.Sheets)
			{
				DestroyRuntimeSheet(sheet);
			}
		}

		private static void DestroyRuntimeSheet(RuntimeSheet sheet)
		{
			Sprite[] sprites = sheet.Sprites;
			for (int i = 0; i < sprites.Length; i++)
			{
				SafeDestroy((Object?)(object)sprites[i]);
			}
			SafeDestroy((Object?)(object)sheet.Material);
			SafeDestroy((Object?)(object)sheet.SpriteAsset);
			SafeDestroy((Object?)(object)sheet.Texture);
		}

		private static void SafeDestroy(Object? value)
		{
			if (value != (Object)null)
			{
				Object.Destroy(value);
			}
		}

		private static void ValidatePngHeader(byte[] data, out int width, out int height)
		{
			if (data.Length < 33 || data.Length > 524288)
			{
				throw new InvalidDataException("PNG file has an invalid size.");
			}
			for (int i = 0; i < PngSignature.Length; i++)
			{
				if (data[i] != PngSignature[i])
				{
					throw new InvalidDataException("File does not have a valid PNG signature.");
				}
			}
			if (ReadUInt32BigEndian(data, 8) != 13 || data[12] != 73 || data[13] != 72 || data[14] != 68 || data[15] != 82)
			{
				throw new InvalidDataException("PNG IHDR must be the first chunk.");
			}
			uint num = ReadUInt32BigEndian(data, 16);
			uint num2 = ReadUInt32BigEndian(data, 20);
			if (num == 0 || num2 == 0 || num > 512 || num2 > 512)
			{
				throw new InvalidDataException("PNG dimensions are outside the supported range.");
			}
			byte num3 = data[24];
			int num4 = data[25];
			if (num3 != 8 || (num4 != 0 && num4 != 2 && num4 != 3 && num4 != 4 && num4 != 6) || data[26] != 0 || data[27] != 0 || data[28] != 0)
			{
				throw new InvalidDataException("PNG must use 8-bit color, standard compression/filtering, and no interlace.");
			}
			width = (int)num;
			height = (int)num2;
		}

		private static uint ReadUInt32BigEndian(byte[] data, int offset)
		{
			return (uint)((data[offset] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3]);
		}

		private static string ComputeSha256(byte[] data)
		{
			using SHA256 sHA = SHA256.Create();
			return string.Concat(from value in sHA.ComputeHash(data)
				select value.ToString("x2", CultureInfo.InvariantCulture));
		}

		private static bool IsSha256(string value)
		{
			if (value.Length != 64)
			{
				return false;
			}
			foreach (char c in value)
			{
				bool num = c >= '0' && c <= '9';
				bool flag = c >= 'a' && c <= 'f';
				if (!num && !flag)
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsSafeName(string value)
		{
			if (SafeNameRegex.IsMatch(value))
			{
				return !ReservedWindowsNames.Contains(value);
			}
			return false;
		}

		private static HashSet<string> BuildReservedWindowsNames()
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal) { "con", "prn", "aux", "nul" };
			for (int i = 1; i <= 9; i++)
			{
				hashSet.Add("com" + i.ToString(CultureInfo.InvariantCulture));
				hashSet.Add("lpt" + i.ToString(CultureInfo.InvariantCulture));
			}
			return hashSet;
		}

		private static string TokenForName(string name)
		{
			return ":clan_" + name + ":";
		}

		private static string SpriteName(ManifestRecord record, int frameIndex, bool animated)
		{
			string text = ((record.Role == MediaRole.Emblem) ? "clan_emblem_" : ((record.Kind != EmojiFileKind.Gif) ? "clan_emoji_png_" : "clan_emoji_gif_"));
			string text2 = text;
			if (!animated)
			{
				return text2 + record.Name;
			}
			return text2 + record.Name + "_f" + frameIndex.ToString("000", CultureInfo.InvariantCulture);
		}

		private static bool IsCurrentEmojiServerManifest(string manifest)
		{
			if (_serverEmojiCatalog != null)
			{
				return StringComparer.Ordinal.Equals(_serverEmojiCatalog.Manifest, manifest);
			}
			return false;
		}

		private static void InitializeEmojiCache()
		{
			Directory.CreateDirectory(EmojiCacheDirectory);
			DeletePartialEmojiCacheFiles();
		}

		private static void ResetEmojiSyncSession(ZNet? session)
		{
			_clientEmojiCatalog = null;
			_serverEmojiCatalog = null;
			EmojiPeerBudgets.Clear();
			EmojiGlobalTransferBudget.Reset();
			Interlocked.Exchange(ref _emojiReloadRequestedAtTicks, 0L);
			Interlocked.Exchange(ref _emojiReloadFailures, 0);
			Interlocked.Exchange(ref _emojiWatcherNeedsRestart, 0);
			Interlocked.Exchange(ref _emojiWatcherRestartFailures, 0);
			_serverManifestPublishRetryPending = false;
			DisposeEmojiFileWatcher();
			if (session != null && session.IsServer())
			{
				CreateEmojiFileWatcher();
			}
		}

		internal static void RegisterEmojiFileRpc(ZNet znet, ZNetPeer peer)
		{
			if (znet.IsServer())
			{
				peer.m_rpc.Register<ZPackage>(EmojiFileRequestRpc, (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage package)
				{
					HandleEmojiFileRequest(peer, rpc, package);
				});
			}
			else
			{
				peer.m_rpc.Register<ZPackage>(EmojiFileResponseRpc, (Action<ZRpc, ZPackage>)HandleEmojiFileResponse);
			}
		}

		private static ServerEmojiCatalog PrepareEmojiServerCatalog(string manifest, IReadOnlyList<ManifestRecord> records, IReadOnlyCollection<ServerEmojiBlob> blobs)
		{
			Dictionary<string, ServerEmojiBlob> dictionary = new Dictionary<string, ServerEmojiBlob>(StringComparer.Ordinal);
			int num = 0;
			foreach (ServerEmojiBlob blob in blobs)
			{
				if (blob.Data.Length != blob.Record.Length)
				{
					throw new InvalidDataException("Media source '" + blob.Record.Name + "' changed while its catalog was being published.");
				}
				if ((blob.Record.Kind == EmojiFileKind.Gif && (blob.GifFrameCount <= 0 || blob.GifFrameCount > 180)) || (blob.Record.Kind == EmojiFileKind.Png && blob.GifFrameCount != 0))
				{
					throw new InvalidDataException("Media source '" + blob.Record.Name + "' has invalid frame metadata.");
				}
				if (blob.Record.Kind == EmojiFileKind.Gif)
				{
					if (blob.GifFrameCount > 3000 - num)
					{
						throw new InvalidDataException($"Clan media catalog exceeds its {3000} total GIF frame budget.");
					}
					num += blob.GifFrameCount;
				}
				if (dictionary.TryGetValue(blob.Record.Hash, out var value))
				{
					if (value.Record.Length != blob.Record.Length || !StringComparer.Ordinal.Equals(value.Record.Extension, blob.Record.Extension) || value.GifFrameCount != blob.GifFrameCount)
					{
						throw new InvalidDataException("A media content hash maps to conflicting files.");
					}
				}
				else
				{
					dictionary.Add(blob.Record.Hash, blob);
				}
			}
			return new ServerEmojiCatalog(manifest, ComputeSha256(Encoding.UTF8.GetBytes(manifest)), records.ToArray(), dictionary);
		}

		private static void CommitEmojiServerCatalog(ServerEmojiCatalog catalog)
		{
			EmojiPeerBudgets.Clear();
			EmojiGlobalTransferBudget.Reset();
			_serverEmojiCatalog = catalog;
		}

		private static void ClearEmojiServerCatalog()
		{
			_serverEmojiCatalog = null;
			EmojiPeerBudgets.Clear();
			EmojiGlobalTransferBudget.Reset();
		}

		private static void BeginEmojiClientCatalog(string manifest, IReadOnlyList<ManifestRecord> records)
		{
			_clientEmojiCatalog = new ClientEmojiCatalog(ZNet.instance, manifest, ComputeSha256(Encoding.UTF8.GetBytes(manifest)), records);
		}

		private static void CancelEmojiClientCatalog()
		{
			_clientEmojiCatalog = null;
		}

		private static bool IsEmojiClientCatalogReady(string manifest)
		{
			ClientEmojiCatalog clientEmojiCatalog = _clientEmojiCatalog;
			if (clientEmojiCatalog != null && clientEmojiCatalog.Ready && clientEmojiCatalog.Session == ZNet.instance)
			{
				return StringComparer.Ordinal.Equals(clientEmojiCatalog.Manifest, manifest);
			}
			return false;
		}

		private static void TickEmojiSync()
		{
			ClientEmojiCatalog clientEmojiCatalog = _clientEmojiCatalog;
			if (clientEmojiCatalog == null || clientEmojiCatalog.Ready)
			{
				return;
			}
			if (clientEmojiCatalog.Session != ZNet.instance)
			{
				_clientEmojiCatalog = null;
				return;
			}
			if (clientEmojiCatalog.Failed)
			{
				if (clientEmojiCatalog.CatalogRetryCount == 0 && Time.realtimeSinceStartup >= clientEmojiCatalog.CatalogRetryAt)
				{
					clientEmojiCatalog.CatalogRetryCount++;
					clientEmojiCatalog.Failed = false;
					clientEmojiCatalog.Download = null;
					clientEmojiCatalog.NextRecordIndex = 0;
					clientEmojiCatalog.ServerHits = 0;
					clientEmojiCatalog.CacheHits = 0;
					clientEmojiCatalog.ConfigHits = 0;
					clientEmojiCatalog.Downloads = 0;
					ClanPlugin.ClanLogger.LogInfo((object)"Retrying the synchronized Clan media catalog after a transient failure.");
				}
				return;
			}
			ClientEmojiDownload download = clientEmojiCatalog.Download;
			if (download != null)
			{
				TickEmojiDownload(clientEmojiCatalog, download);
				return;
			}
			if (clientEmojiCatalog.NextRecordIndex >= clientEmojiCatalog.Records.Count)
			{
				clientEmojiCatalog.Ready = true;
				ClanPlugin.ClanLogger.LogInfo((object)($"Clan media catalog is ready: {clientEmojiCatalog.ServerHits} server hits, " + $"{clientEmojiCatalog.CacheHits} cache hits, {clientEmojiCatalog.ConfigHits} config hits, " + $"{clientEmojiCatalog.Downloads} downloaded files."));
				return;
			}
			ManifestRecord manifestRecord = clientEmojiCatalog.Records[clientEmojiCatalog.NextRecordIndex];
			if (TryReadSyncedEmojiFile(manifestRecord, out byte[] _, out SyncedMediaFileSource source))
			{
				switch (source)
				{
				case SyncedMediaFileSource.Server:
					clientEmojiCatalog.ServerHits++;
					break;
				case SyncedMediaFileSource.Cache:
					clientEmojiCatalog.CacheHits++;
					break;
				case SyncedMediaFileSource.Config:
					clientEmojiCatalog.ConfigHits++;
					break;
				default:
					throw new InvalidOperationException("A synchronized Clan media file was resolved without a source.");
				}
				clientEmojiCatalog.NextRecordIndex++;
			}
			else
			{
				ZNet instance = ZNet.instance;
				if (instance != null && instance.IsServer())
				{
					FailEmojiClientCatalog(clientEmojiCatalog, "The listen server catalog does not contain '" + manifestRecord.Name + "'.");
				}
				else
				{
					clientEmojiCatalog.Download = new ClientEmojiDownload(manifestRecord);
				}
			}
		}

		private static void TickEmojiDownload(ClientEmojiCatalog catalog, ClientEmojiDownload download)
		{
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (download.Completed)
			{
				try
				{
					string x = ComputeSha256(download.Buffer);
					if (!StringComparer.Ordinal.Equals(x, download.Record.Hash))
					{
						throw new InvalidDataException("Downloaded SHA-256 does not match the manifest.");
					}
					WriteEmojiCacheAtomically(download.Record, download.Buffer);
					catalog.Download = null;
					catalog.NextRecordIndex++;
					catalog.Downloads++;
					PruneEmojiCache(catalog.Records);
					return;
				}
				catch (Exception ex)
				{
					FailEmojiClientCatalog(catalog, "Downloaded media file '" + download.Record.Name + "' could not be cached: " + ex.Message);
					return;
				}
			}
			for (int i = 0; i < download.ChunkCount; i++)
			{
				if (download.IsResponseTimedOut(i, realtimeSinceStartup))
				{
					RetryEmojiChunk(catalog, download, i, "response timed out", 0.25f);
					if (catalog.Failed)
					{
						return;
					}
				}
			}
			ZNet instance = ZNet.instance;
			ZRpc val = ((instance != null) ? instance.GetServerRPC() : null);
			if (val == null)
			{
				return;
			}
			ISocket socket = val.GetSocket();
			if (socket == null || !socket.IsConnected())
			{
				return;
			}
			int chunkIndex;
			while (download.InFlightCount < 4 && download.TryGetNextRequestChunk(realtimeSinceStartup, out chunkIndex))
			{
				int num = chunkIndex * 65536;
				int num2 = download.MarkRequested(chunkIndex, realtimeSinceStartup + 5f);
				ZPackage val2 = new ZPackage();
				val2.Write(3);
				val2.Write(catalog.CatalogId);
				val2.Write(download.Record.Hash);
				val2.Write(num);
				val2.Write(num2);
				try
				{
					val.Invoke(EmojiFileRequestRpc, new object[1] { val2 });
				}
				catch (Exception ex2)
				{
					RetryEmojiChunk(catalog, download, chunkIndex, ex2.Message, 0.25f);
					if (catalog.Failed)
					{
						break;
					}
				}
			}
		}

		private static void HandleEmojiFileRequest(ZNetPeer peer, ZRpc rpc, ZPackage package)
		{
			try
			{
				ZNet instance = ZNet.instance;
				if (instance == null || !instance.IsServer() || peer.m_rpc != rpc || !peer.IsReady() || package.Size() <= 0 || package.Size() > 512 || !ConsumeEmojiPeerRequest(rpc))
				{
					return;
				}
				package.SetPos(0);
				int num = package.ReadInt();
				string text = package.ReadString();
				string text2 = package.ReadString();
				int num2 = package.ReadInt();
				int num3 = package.ReadInt();
				RequireEmojiPackageConsumed(package);
				if (num != 3 || !IsSha256(text) || !IsSha256(text2) || num2 < 0 || num2 % 65536 != 0 || num3 <= 0)
				{
					SendEmojiFileResponse(rpc, EmojiFileResponseStatus.Rejected, text, text2, 0, num2, num3, null);
					return;
				}
				ServerEmojiCatalog serverEmojiCatalog = _serverEmojiCatalog;
				if (serverEmojiCatalog == null || !StringComparer.Ordinal.Equals(serverEmojiCatalog.CatalogId, text))
				{
					SendEmojiFileResponse(rpc, EmojiFileResponseStatus.StaleCatalog, text, text2, 0, num2, num3, null);
					return;
				}
				if (!serverEmojiCatalog.Files.TryGetValue(text2, out ServerEmojiBlob value) || num2 >= value.Data.Length)
				{
					SendEmojiFileResponse(rpc, EmojiFileResponseStatus.Unavailable, text, text2, 0, num2, num3, null);
					return;
				}
				int num4 = Math.Min(65536, value.Data.Length - num2);
				ISocket socket = rpc.GetSocket();
				if (((socket != null) ? socket.GetSendQueueSize() : int.MaxValue) > 262144 - num4 || !ConsumeEmojiTransferBytes(rpc, num4))
				{
					SendEmojiFileResponse(rpc, EmojiFileResponseStatus.Busy, text, text2, value.Data.Length, num2, num3, null);
					return;
				}
				byte[] array = new byte[num4];
				Buffer.BlockCopy(value.Data, num2, array, 0, num4);
				SendEmojiFileResponse(rpc, EmojiFileResponseStatus.Data, text, text2, value.Data.Length, num2, num3, array);
			}
			catch (Exception ex)
			{
				if (ShouldLogMalformedEmojiRequest(rpc))
				{
					ClanPlugin.ClanLogger.LogWarning((object)("Rejected malformed Clan media file request: " + ex.Message));
				}
			}
		}

		private static void HandleEmojiFileResponse(ZRpc rpc, ZPackage package)
		{
			try
			{
				ZNet instance = ZNet.instance;
				if (rpc != ((instance != null) ? instance.GetServerRPC() : null) || package.Size() <= 0 || package.Size() > 66048)
				{
					return;
				}
				package.SetPos(0);
				int num = package.ReadInt();
				EmojiFileResponseStatus emojiFileResponseStatus = (EmojiFileResponseStatus)package.ReadByte();
				string text = package.ReadString();
				string text2 = package.ReadString();
				int num2 = package.ReadInt();
				int num3 = package.ReadInt();
				int num4 = package.ReadInt();
				if (num != 3 || !Enum.IsDefined(typeof(EmojiFileResponseStatus), emojiFileResponseStatus) || !IsSha256(text) || !IsSha256(text2) || num2 < 0 || num3 < 0 || num3 % 65536 != 0 || num4 <= 0)
				{
					throw new InvalidDataException("Emoji response header is invalid.");
				}
				byte[] array = null;
				if (emojiFileResponseStatus == EmojiFileResponseStatus.Data)
				{
					int num5 = package.ReadInt();
					int num6 = package.Size() - package.GetPos();
					if (num5 <= 0 || num5 > 65536 || num6 != num5)
					{
						throw new InvalidDataException("Emoji response chunk length is invalid.");
					}
					array = package.ReadByteArray(num5);
				}
				RequireEmojiPackageConsumed(package);
				ClientEmojiCatalog clientEmojiCatalog = _clientEmojiCatalog;
				ClientEmojiDownload clientEmojiDownload = clientEmojiCatalog?.Download;
				if (clientEmojiCatalog == null || clientEmojiDownload == null || clientEmojiCatalog.Failed || clientEmojiCatalog.Session != ZNet.instance || !StringComparer.Ordinal.Equals(clientEmojiCatalog.CatalogId, text) || !StringComparer.Ordinal.Equals(clientEmojiDownload.Record.Hash, text2) || !clientEmojiDownload.TryGetChunkIndex(num3, out var chunkIndex) || !clientEmojiDownload.HasIssuedRequest(chunkIndex, num4) || clientEmojiDownload.IsChunkReceived(chunkIndex))
				{
					return;
				}
				if ((emojiFileResponseStatus == EmojiFileResponseStatus.Data || emojiFileResponseStatus == EmojiFileResponseStatus.Busy) ? (num2 != clientEmojiDownload.Record.Length) : ((byte)num2 != 0))
				{
					throw new InvalidDataException("Emoji response length is invalid for its status.");
				}
				switch (emojiFileResponseStatus)
				{
				case EmojiFileResponseStatus.Data:
					if (array == null || num2 != clientEmojiDownload.Record.Length || array.Length != Math.Min(65536, clientEmojiDownload.Record.Length - num3))
					{
						throw new InvalidDataException("Emoji response does not match the manifest.");
					}
					Buffer.BlockCopy(array, 0, clientEmojiDownload.Buffer, num3, array.Length);
					clientEmojiDownload.MarkReceived(chunkIndex, array.Length);
					break;
				case EmojiFileResponseStatus.Busy:
					if (clientEmojiDownload.IsCurrentRequest(chunkIndex, num4))
					{
						clientEmojiDownload.DeferChunk(chunkIndex, Time.realtimeSinceStartup + 0.1f);
					}
					break;
				case EmojiFileResponseStatus.StaleCatalog:
					if (clientEmojiDownload.IsCurrentRequest(chunkIndex, num4))
					{
						FailEmojiClientCatalog(clientEmojiCatalog, "The server replaced the media catalog during download.");
					}
					break;
				case EmojiFileResponseStatus.Unavailable:
				case EmojiFileResponseStatus.Rejected:
					if (clientEmojiDownload.IsCurrentRequest(chunkIndex, num4))
					{
						RetryEmojiChunk(clientEmojiCatalog, clientEmojiDownload, chunkIndex, emojiFileResponseStatus.ToString(), 0.25f);
					}
					break;
				}
			}
			catch (Exception ex)
			{
				ClientEmojiCatalog clientEmojiCatalog2 = _clientEmojiCatalog;
				if (clientEmojiCatalog2 != null)
				{
					FailEmojiClientCatalog(clientEmojiCatalog2, "Malformed Clan media response was rejected: " + ex.Message);
				}
			}
		}

		private static void SendEmojiFileResponse(ZRpc rpc, EmojiFileResponseStatus status, string catalogId, string hash, int totalLength, int offset, int requestId, byte[]? chunk)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(3);
			val.Write((byte)status);
			val.Write(catalogId);
			val.Write(hash);
			val.Write(totalLength);
			val.Write(offset);
			val.Write(requestId);
			if (status == EmojiFileResponseStatus.Data)
			{
				val.Write(chunk ?? throw new ArgumentNullException("chunk"));
			}
			rpc.Invoke(EmojiFileResponseRpc, new object[1] { val });
		}

		private static bool ConsumeEmojiPeerRequest(ZRpc rpc)
		{
			return GetEmojiPeerBudget(rpc).TryConsumeRequest(Time.realtimeSinceStartup);
		}

		private static bool ConsumeEmojiTransferBytes(ZRpc rpc, int bytes)
		{
			if (bytes <= 0 || bytes > 65536)
			{
				return false;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			PeerTransferBudget emojiPeerBudget = GetEmojiPeerBudget(rpc);
			emojiPeerBudget.Refill(realtimeSinceStartup);
			EmojiGlobalTransferBudget.Refill(realtimeSinceStartup);
			if (emojiPeerBudget.ByteTokens < (double)bytes || EmojiGlobalTransferBudget.ByteTokens < (double)bytes)
			{
				return false;
			}
			emojiPeerBudget.ByteTokens -= bytes;
			EmojiGlobalTransferBudget.ByteTokens -= bytes;
			return true;
		}

		private static bool ShouldLogMalformedEmojiRequest(ZRpc rpc)
		{
			return GetEmojiPeerBudget(rpc).TryConsumeMalformedLog(Time.realtimeSinceStartup);
		}

		private static PeerTransferBudget GetEmojiPeerBudget(ZRpc rpc)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!EmojiPeerBudgets.TryGetValue(rpc, out PeerTransferBudget value))
			{
				value = new PeerTransferBudget(realtimeSinceStartup);
				EmojiPeerBudgets[rpc] = value;
			}
			return value;
		}

		internal static void ForgetEmojiPeer(ZRpc? rpc)
		{
			if (rpc != null)
			{
				EmojiPeerBudgets.Remove(rpc);
			}
		}

		private static void RetryEmojiChunk(ClientEmojiCatalog catalog, ClientEmojiDownload download, int chunkIndex, string reason, float delay)
		{
			int num = download.IncrementRetry(chunkIndex);
			if (num > 3)
			{
				FailEmojiClientCatalog(catalog, "Emoji '" + download.Record.Name + "' could not be downloaded: " + reason + ".");
			}
			else
			{
				download.DeferChunk(chunkIndex, Time.realtimeSinceStartup + delay * (float)(1 << num - 1));
			}
		}

		private static void FailEmojiClientCatalog(ClientEmojiCatalog catalog, string message)
		{
			if (!catalog.Failed)
			{
				catalog.Failed = true;
				catalog.Download = null;
				if (catalog.CatalogRetryCount == 0)
				{
					catalog.CatalogRetryAt = Time.realtimeSinceStartup + 30f;
				}
				ClanPlugin.ClanLogger.LogWarning((object)(message + " The previous Clan media set remains active." + ((catalog.CatalogRetryCount == 0) ? " The catalog will be retried once." : "")));
			}
		}

		private static byte[] ReadSyncedEmojiFile(ManifestRecord record)
		{
			if (!TryReadSyncedEmojiFile(record, out byte[] data))
			{
				throw new FileNotFoundException("Synchronized file '" + record.Name + record.Extension + "' is not available.");
			}
			return data;
		}

		private static bool TryReadSyncedEmojiFile(ManifestRecord record, out byte[] data)
		{
			SyncedMediaFileSource source;
			return TryReadSyncedEmojiFile(record, out data, out source);
		}

		private static bool TryReadSyncedEmojiFile(ManifestRecord record, out byte[] data, out SyncedMediaFileSource source)
		{
			ZNet instance = ZNet.instance;
			ServerEmojiCatalog serverEmojiCatalog = _serverEmojiCatalog;
			if (instance != null && instance.IsServer() && serverEmojiCatalog != null && serverEmojiCatalog.Files.TryGetValue(record.Hash, out ServerEmojiBlob value) && value.Data.Length == record.Length && StringComparer.Ordinal.Equals(value.Record.Extension, record.Extension))
			{
				data = value.Data;
				source = SyncedMediaFileSource.Server;
				return true;
			}
			if (TryReadEmojiCacheFile(record, out data))
			{
				source = SyncedMediaFileSource.Cache;
				return true;
			}
			if ((Object)(object)instance != (Object)null && !instance.IsServer() && TryReadConfiguredMediaFile(record, out data))
			{
				source = SyncedMediaFileSource.Config;
				return true;
			}
			source = SyncedMediaFileSource.None;
			return false;
		}

		private static bool TryReadConfiguredMediaFile(ManifestRecord record, out byte[] data)
		{
			string path;
			switch (record.Role)
			{
			case MediaRole.Emoji:
				path = EmojiDirectory;
				break;
			case MediaRole.Emblem:
				path = EmblemDirectory;
				break;
			default:
				data = Array.Empty<byte>();
				return false;
			}
			string path2 = Path.Combine(path, record.Name + record.Extension);
			return TryReadVerifiedMediaFile(record, path2, out data);
		}

		private static bool TryReadVerifiedMediaFile(ManifestRecord record, string path, out byte[] data)
		{
			try
			{
				FileInfo fileInfo = new FileInfo(path);
				if (!fileInfo.Exists || fileInfo.Length != record.Length)
				{
					data = Array.Empty<byte>();
					return false;
				}
				data = ReadStableFile(path, record.Length);
				if (!StringComparer.Ordinal.Equals(ComputeSha256(data), record.Hash))
				{
					data = Array.Empty<byte>();
					return false;
				}
				return true;
			}
			catch
			{
				data = Array.Empty<byte>();
				return false;
			}
		}

		private static bool TryReadEmojiCacheFile(ManifestRecord record, out byte[] data)
		{
			string path = EmojiCachePath(record);
			if (!TryReadVerifiedMediaFile(record, path, out data))
			{
				return false;
			}
			try
			{
				File.SetLastWriteTimeUtc(path, DateTime.UtcNow);
			}
			catch
			{
			}
			return true;
		}

		private static void WriteEmojiCacheAtomically(ManifestRecord record, byte[] data)
		{
			if (data.Length != record.Length || !StringComparer.Ordinal.Equals(ComputeSha256(data), record.Hash))
			{
				throw new InvalidDataException("Cache data for '" + record.Name + record.Extension + "' does not match its manifest.");
			}
			Directory.CreateDirectory(EmojiCacheDirectory);
			string text = EmojiCachePath(record);
			if (TryReadEmojiCacheFile(record, out byte[] _))
			{
				return;
			}
			string text2 = text + "." + Guid.NewGuid().ToString("N") + ".part";
			try
			{
				using (FileStream fileStream = new FileStream(text2, FileMode.CreateNew, FileAccess.Write, FileShare.None))
				{
					fileStream.Write(data, 0, data.Length);
					fileStream.Flush(flushToDisk: true);
				}
				PublishEmojiCacheFile(record, text2, text);
			}
			finally
			{
				TryDeleteFile(text2);
			}
		}

		private static void PublishEmojiCacheFile(ManifestRecord record, string temporary, string destination)
		{
			byte[] data;
			try
			{
				File.Move(temporary, destination);
				return;
			}
			catch (IOException)
			{
				if (TryReadEmojiCacheFile(record, out data))
				{
					return;
				}
			}
			try
			{
				File.Replace(temporary, destination, null);
			}
			catch (IOException)
			{
				if (TryReadEmojiCacheFile(record, out data))
				{
					return;
				}
				if (File.Exists(destination))
				{
					throw;
				}
				try
				{
					File.Move(temporary, destination);
				}
				catch (IOException) when (TryReadEmojiCacheFile(record, out data))
				{
				}
			}
		}

		private static string EmojiCachePath(ManifestRecord record)
		{
			return Path.Combine(EmojiCacheDirectory, record.Hash + record.Extension);
		}

		private static void PruneEmojiCache(IReadOnlyList<ManifestRecord> activeRecords)
		{
			FileStream fileStream = null;
			try
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(EmojiCacheDirectory);
				if (!directoryInfo.Exists)
				{
					return;
				}
				try
				{
					fileStream = new FileStream(Path.Combine(EmojiCacheDirectory, ".prune.lock"), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
				}
				catch (IOException)
				{
					return;
				}
				List<FileInfo> source = (from file in directoryInfo.EnumerateFiles("*", SearchOption.TopDirectoryOnly)
					where StringComparer.Ordinal.Equals(file.Extension, ".png") || StringComparer.Ordinal.Equals(file.Extension, ".gif")
					select file).ToList();
				long num = source.Sum((FileInfo file) => file.Length);
				if (num <= 402653184)
				{
					return;
				}
				HashSet<string> active = (from record in _activeRecords.Concat(activeRecords)
					select record.Hash + record.Extension).ToHashSet<string>(StringComparer.Ordinal);
				foreach (FileInfo item in from file in source
					where !active.Contains(file.Name)
					orderby file.LastWriteTimeUtc
					select file)
				{
					long length = item.Length;
					TryDeleteFile(item.FullName);
					if (!File.Exists(item.FullName))
					{
						num -= length;
					}
					if (num <= 335544320)
					{
						break;
					}
				}
			}
			catch (Exception ex2)
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Clan media cache cleanup failed: " + ex2.Message));
			}
			finally
			{
				fileStream?.Dispose();
			}
		}

		private static void DeletePartialEmojiCacheFiles()
		{
			if (!Directory.Exists(EmojiCacheDirectory))
			{
				return;
			}
			long num = DateTime.UtcNow.Ticks - 864000000000L;
			foreach (string item in Directory.EnumerateFiles(EmojiCacheDirectory, "*.part", SearchOption.TopDirectoryOnly))
			{
				try
				{
					if (File.GetLastWriteTimeUtc(item).Ticks <= num)
					{
						TryDeleteFile(item);
					}
				}
				catch
				{
				}
			}
		}

		private static void TryDeleteFile(string path)
		{
			try
			{
				if (File.Exists(path))
				{
					File.Delete(path);
				}
			}
			catch
			{
			}
		}

		private static void CreateEmojiFileWatcher()
		{
			FileSystemWatcher fileSystemWatcher = null;
			FileSystemWatcher fileSystemWatcher2 = null;
			try
			{
				Directory.CreateDirectory(EmojiDirectory);
				Directory.CreateDirectory(EmblemDirectory);
				fileSystemWatcher = CreateMediaFileWatcher(EmojiDirectory);
				fileSystemWatcher2 = CreateMediaFileWatcher(EmblemDirectory);
				_emojiFileWatcher = fileSystemWatcher;
				_emblemFileWatcher = fileSystemWatcher2;
				Interlocked.Exchange(ref _emojiWatcherRestartFailures, 0);
			}
			catch (Exception ex)
			{
				DisposeMediaFileWatcher(fileSystemWatcher);
				DisposeMediaFileWatcher(fileSystemWatcher2);
				_emojiFileWatcher = null;
				_emblemFileWatcher = null;
				ClanPlugin.ClanLogger.LogWarning((object)("Clan media hot reload watchers could not be started: " + ex.Message));
				if (Interlocked.Increment(ref _emojiWatcherRestartFailures) <= 3)
				{
					Interlocked.Exchange(ref _emojiWatcherNeedsRestart, 1);
					Interlocked.Exchange(ref _emojiReloadRequestedAtTicks, DateTime.UtcNow.Ticks);
				}
			}
		}

		private static FileSystemWatcher CreateMediaFileWatcher(string directory)
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(directory);
			fileSystemWatcher.IncludeSubdirectories = false;
			fileSystemWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite | NotifyFilters.CreationTime;
			fileSystemWatcher.Changed += OnEmojiFileChanged;
			fileSystemWatcher.Created += OnEmojiFileChanged;
			fileSystemWatcher.Deleted += OnEmojiFileChanged;
			fileSystemWatcher.Renamed += OnEmojiFileRenamed;
			fileSystemWatcher.Error += OnEmojiWatcherError;
			fileSystemWatcher.EnableRaisingEvents = true;
			return fileSystemWatcher;
		}

		private static void DisposeEmojiFileWatcher()
		{
			FileSystemWatcher emojiFileWatcher = _emojiFileWatcher;
			FileSystemWatcher? emblemFileWatcher = _emblemFileWatcher;
			_emojiFileWatcher = null;
			_emblemFileWatcher = null;
			DisposeMediaFileWatcher(emojiFileWatcher);
			DisposeMediaFileWatcher(emblemFileWatcher);
		}

		private static void DisposeMediaFileWatcher(FileSystemWatcher? watcher)
		{
			if (watcher != null)
			{
				watcher.EnableRaisingEvents = false;
				watcher.Changed -= OnEmojiFileChanged;
				watcher.Created -= OnEmojiFileChanged;
				watcher.Deleted -= OnEmojiFileChanged;
				watcher.Renamed -= OnEmojiFileRenamed;
				watcher.Error -= OnEmojiWatcherError;
				watcher.Dispose();
			}
		}

		private static void OnEmojiFileChanged(object sender, FileSystemEventArgs args)
		{
			if (IsSupportedEmojiPath(args.FullPath))
			{
				MarkEmojiServerFileDirty(args.FullPath);
			}
		}

		private static void OnEmojiFileRenamed(object sender, RenamedEventArgs args)
		{
			if (IsSupportedEmojiPath(args.OldFullPath))
			{
				MarkEmojiServerFileDirty(args.OldFullPath);
			}
			if (IsSupportedEmojiPath(args.FullPath))
			{
				MarkEmojiServerFileDirty(args.FullPath);
			}
		}

		private static void OnEmojiWatcherError(object sender, ErrorEventArgs args)
		{
			Interlocked.Exchange(ref _emojiWatcherRestartFailures, 0);
			Interlocked.Exchange(ref _emojiWatcherNeedsRestart, 1);
			MarkAllEmojiServerFilesDirty();
		}

		private static void MarkAllEmojiServerFilesDirty()
		{
			try
			{
				string[] array = new string[2] { EmojiDirectory, EmblemDirectory };
				foreach (string path in array)
				{
					if (!Directory.Exists(path))
					{
						continue;
					}
					foreach (string item in Directory.EnumerateFiles(path, "*", SearchOption.TopDirectoryOnly))
					{
						if (IsSupportedEmojiPath(item))
						{
							MarkEmojiServerFileDirty(item);
						}
					}
				}
			}
			catch
			{
			}
			MarkEmojiServerFilesDirty();
		}

		private static bool IsSupportedEmojiPath(string path)
		{
			string extension = Path.GetExtension(path);
			if (!StringComparer.Ordinal.Equals(extension, ".png"))
			{
				return StringComparer.Ordinal.Equals(extension, ".gif");
			}
			return true;
		}

		private static void MarkEmojiServerFilesDirty()
		{
			Interlocked.Exchange(ref _emojiReloadFailures, 0);
			Interlocked.Exchange(ref _emojiReloadRequestedAtTicks, DateTime.UtcNow.Ticks);
		}

		private static bool ConsumeEmojiServerReloadRequest()
		{
			long num = Interlocked.Read(in _emojiReloadRequestedAtTicks);
			if (num == 0L || DateTime.UtcNow.Ticks - num < 7500000)
			{
				return false;
			}
			if (Interlocked.CompareExchange(ref _emojiReloadRequestedAtTicks, 0L, num) != num)
			{
				return false;
			}
			if (Interlocked.Exchange(ref _emojiWatcherNeedsRestart, 0) != 0)
			{
				DisposeEmojiFileWatcher();
				CreateEmojiFileWatcher();
			}
			return true;
		}

		private static void ResetEmojiServerReloadFailures()
		{
			Interlocked.Exchange(ref _emojiReloadFailures, 0);
		}

		private static void ScheduleEmojiServerReloadRetry(Exception error, bool retryAnyError = false)
		{
			if ((retryAnyError || error is IOException || error is InvalidDataException) && Interlocked.Increment(ref _emojiReloadFailures) <= 3)
			{
				Interlocked.Exchange(ref _emojiReloadRequestedAtTicks, DateTime.UtcNow.Ticks);
			}
		}

		private static void RequireEmojiPackageConsumed(ZPackage package)
		{
			if (package.GetPos() != package.Size())
			{
				throw new InvalidDataException("Emoji RPC contains unexpected trailing data.");
			}
		}
	}
	internal static class ClanUiFactory
	{
		private const float ScrollSensitivity = 196f;

		private const float UnderfilledScrollSensitivity = 35f;

		private const float UnderfilledScrollElasticity = 0.07f;

		private const float RectComparisonTolerance = 0.25f;

		private static readonly Color FixedClanColor = new Color(0.48f, 0.92f, 0.78f, 1f);

		private static readonly Vector3[] WorldCorners = (Vector3[])(object)new Vector3[4];

		public static Color GetClanColor()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return FixedClanColor;
		}

		public static GameObject CreateObject(string name, Transform parent, params Type[] components)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			Type[] array = new Type[components.Length + 1];
			array[0] = typeof(RectTransform);
			Array.Copy(components, 0, array, 1, components.Length);
			GameObject val = new GameObject(name, array);
			val.transform.SetParent(parent, false);
			val.layer = 5;
			return val;
		}

		public static void ClearChildren(Transform parent)
		{
			for (int num = parent.childCount - 1; num >= 0; num--)
			{
				GameObject gameObject = ((Component)parent.GetChild(num)).gameObject;
				gameObject.SetActive(false);
				Object.Destroy((Object)(object)gameObject);
			}
		}

		public static Font GetBoldFont()
		{
			try
			{
				return GUIManager.Instance.AveriaSerifBold;
			}
			catch (Exception)
			{
				return Resources.GetBuiltinResource<Font>("Arial.ttf");
			}
		}

		public static Camera? GetCanvasCamera(Component? component)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			Canvas val = (((Object)(object)component == (Object)null) ? null : component.GetComponentInParent<Canvas>());
			if (!((Object)(object)val == (Object)null) && (int)val.renderMode != 0)
			{
				return val.worldCamera;
			}
			return null;
		}

		public static Rect GetScreenBounds(RectTransform rect, Camera? camera)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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)
			rect.GetWorldCorners(WorldCorners);
			Vector2 val = RectTransformUtility.WorldToScreenPoint(camera, WorldCorners[0]);
			float num = val.x;
			float num2 = val.x;
			float num3 = val.y;
			float num4 = val.y;
			for (int i = 1; i < WorldCorners.Length; i++)
			{
				Vector2 val2 = RectTransformUtility.WorldToScreenPoint(camera, WorldCorners[i]);
				num = Mathf.Min(num, val2.x);
				num2 = Mathf.Max(num2, val2.x);
				num3 = Mathf.Min(num3, val2.y);
				num4 = Mathf.Max(num4, val2.y);
			}
			return Rect.MinMaxRect(num, num3, num2, num4);
		}

		public static bool RectApproximately(Rect left, Rect right)
		{
			if (Mathf.Abs(((Rect)(ref left)).xMin - ((Rect)(ref right)).xMin) <= 0.25f && Mathf.Abs(((Rect)(ref left)).yMin - ((Rect)(ref right)).yMin) <= 0.25f && Mathf.Abs(((Rect)(ref left)).xMax - ((Rect)(ref right)).xMax) <= 0.25f)
			{
				return Mathf.Abs(((Rect)(ref left)).yMax - ((Rect)(ref right)).yMax) <= 0.25f;
			}
			return false;
		}

		public static string CleanSingleLine(string? value)
		{
			return (value ?? "").Replace('\r', ' ').Replace('\n', ' ').Replace('<', ' ')
				.Replace('>', ' ')
				.Trim();
		}

		public static void ConfigureVerticalScroll(ScrollRect scroll, bool hasOverflow, RectTransform? resetContentOnTransition = null)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			MovementType val = (MovementType)((!hasOverflow) ? 1 : 2);
			bool num = scroll.movementType != val;
			scroll.movementType = val;
			scroll.scrollSensitivity = (hasOverflow ? 196f : 35f);
			scroll.elasticity = 0.07f;
			if (num && !((Object)(object)resetContentOnTransition == (Object)null))
			{
				scroll.StopMovement();
				if (!hasOverflow)
				{
					resetContentOnTransition.anchoredPosition = Vector2.zero;
				}
			}
		}
	}
	internal enum ClanActionIcon
	{
		Edit,
		Folder,
		Resize,
		Collapse,
		Expand,
		Accept,
		Decline
	}
	internal enum ClanTooltipPlacement
	{
		Default,
		LeftOfTarget
	}
	internal static class ClanUiFeedback
	{
		private sealed class IconAsset
		{
			internal Texture2D Texture { get; }

			internal Sprite Sprite { get; }

			internal IconAsset(Texture2D texture, Sprite sprite)
			{
				Texture = texture;
				Sprite = sprite;
			}
		}

		private sealed class TooltipTrigger : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler, ISelectHandler, IDeselectHandler
		{
			private Selectable? _target;

			private string _value = "";

			private bool _scheduled;

			private bool _shown;

			private bool _pointerInside;

			private bool _usePointerPosition;

			private bool _richText;

			private ClanTooltipPlacement _placement;

			private Vector2 _pointerPosition;

			private float _showAt;

			internal void Configure(Selectable target, string value, bool richText, ClanTooltipPlacement placement)
			{
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				string text = value?.Trim() ?? "";
				if ((Object)(object)_target == (Object)(object)target && _value == text && _richText == richText && _placement == placement)
				{
					((Behaviour)this).enabled = text.Length > 0;
					return;
				}
				bool num = (Object)(object)_target == (Object)(object)target && _pointerInside && text.Length > 0;
				Cancel();
				_target = target;
				_value = text;
				_richText = richText;
				_placement = placement;
				((Behaviour)this).enabled = _value.Length > 0;
				if (num)
				{
					_usePointerPosition = true;
					_pointerPosition = Vector2.op_Implicit(Input.mousePosition);
					_shown = ShowTooltip(this, target, _value, usePointerPosition: true, _pointerPosition, _richText, _placement);
				}
			}

			public void OnPointerEnter(PointerEventData eventData)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				_pointerInside = true;
				Schedule(usePointerPosition: true, eventData.position);
			}

			public void OnPointerExit(PointerEventData eventData)
			{
				_pointerInside = false;
				Cancel();
			}

			public void OnSelect(BaseEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				Schedule(usePointerPosition: false, Vector2.zero);
			}

			public void OnDeselect(BaseEventData eventData)
			{
				Cancel();
			}

			private void Update()
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				if (_scheduled && Time.unscaledTime >= _showAt)
				{
					_scheduled = false;
					_shown = (Object)(object)_target != (Object)null && ShowTooltip(this, _target, _value, _usePointerPosition, _pointerPosition, _richText, _placement);
				}
				else if (_shown && IsTooltipRootMissingFor(this) && (Object)(object)_target != (Object)null)
				{
					_shown = ShowTooltip(this, _target, _value, _usePointerPosition, _pointerPosition, _richText, _placement);
				}
			}

			private void OnDisable()
			{
				_pointerInside = false;
				Cancel();
			}

			private void OnDestroy()
			{
				_pointerInside = false;
				Cancel();
			}

			internal void NotifyTooltipHidden()
			{
				_shown = false;
			}

			private void Schedule(bool usePointerPosition, Vector2 pointerPosition)
			{
				//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)
				if (((Behaviour)this).enabled && !((Object)(object)_target == (Object)null) && !string.IsNullOrWhiteSpace(_value))
				{
					HideTooltip(this);
					_usePointerPosition = usePointerPosition;
					_pointerPosition = pointerPosition;
					_showAt = Time.unscaledTime + 0.2f;
					_scheduled = true;
					_shown = false;
				}
			}

			private void Cancel()
			{
				_scheduled = false;
				_shown = false;
				HideTooltip(this);
			}
		}

		private const int IconPixels = 32;

		private const float TooltipDelaySeconds = 0.2f;

		private const float TooltipScreenGap = 6f;

		private const float TooltipPointerOffset = 14f;

		private const float TooltipHorizontalPadding = 9f;

		private const float TooltipVerticalPadding = 5f;

		private const float TooltipMaximumTextWidth = 320f;

		private const float TooltipMaximumHeight = 160f;

		private const float NotificationPulsePeriodSeconds = 1f;

		private const string IconObjectName = "ClanActionIcon";

		private static readonly Dictionary<ClanActionIcon, IconAsset> IconAssets = new Dictionary<ClanActionIcon, IconAsset>();

		private static readonly Vector3[] TooltipWorldCorners = (Vector3[])(object)new Vector3[4];

		private static GameObject? _tooltipRoot;

		private static RectTransform? _tooltipRect;

		private static Text? _tooltipText;

		private static Transform? _tooltipHost;

		private static Canvas? _tooltipCanvas;

		private static TooltipTrigger? _tooltipOwner;

		internal static Color GetNotificationPulseColor()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Repeat(Time.unscaledTime, 1f) / 1f;
			float num2 = 0.5f - 0.5f * Mathf.Cos(num * (float)Math.PI * 2f);
			return Color.Lerp(Color.white, ClanUiFactory.GetClanColor(), num2);
		}

		internal static Image ApplyIcon(Button button, ClanActionIcon icon, string tooltip, float displaySize = 32f)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_0108: 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_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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)button == (Object)null)
			{
				throw new ArgumentNullException("button");
			}
			Text[] componentsInChildren = ((Component)button).GetComponentsInChildren<Text>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].text = "";
			}
			TMP_Text[] componentsInChildren2 = ((Component)button).GetComponentsInChildren<TMP_Text>(true);
			for (int i = 0; i < componentsInChildren2.Length; i++)
			{
				componentsInChildren2[i].text = "";
			}
			Transform val = ((Component)button).transform.Find("ClanActionIcon");
			GameObject val2;
			if ((Object)(object)val != (Object)null)
			{
				val2 = ((Component)val).gameObject;
			}
			else
			{
				val2 = new GameObject("ClanActionIcon", new Type[3]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image)
				});
				val2.transform.SetParent(((Component)button).transform, false);
			}
			val2.layer = ((Component)button).gameObject.layer;
			val2.SetActive(true);
			val2.transform.SetAsLastSibling();
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = Vector2.zero;
			float num = Mathf.Max(1f, displaySize);
			component.sizeDelta = new Vector2(num, num);
			Image component2 = val2.GetComponent<Image>();
			component2.sprite = GetIcon(icon);
			((Graphic)component2).color = Color.white;
			component2.preserveAspect = true;
			((Graphic)component2).raycastTarget = false;
			SetTooltip((Selectable)(object)button, tooltip);
			return component2;
		}

		internal static void SetTooltip(Selectable selectable, string tooltip, bool richText = false, ClanTooltipPlacement placement = ClanTooltipPlacement.Default)
		{
			if ((Object)(object)selectable == (Object)null)
			{
				throw new ArgumentNullException("selectable");
			}
			(((Component)selectable).GetComponent<TooltipTrigger>() ?? ((Component)selectable).gameObject.AddComponent<TooltipTrigger>()).Configure(selectable, tooltip, richText, placement);
		}

		internal static Sprite GetIcon(ClanActionIcon icon)
		{
			if (IconAssets.TryGetValue(icon, out IconAsset value) && (Object)(object)value.Texture != (Object)null && (Object)(object)value.Sprite != (Object)null)
			{
				return value.Sprite;
			}
			if (value != null)
			{
				DestroyObject((Object?)(object)value.Sprite);
				DestroyObject((Object?)(object)value.Texture);
				IconAssets.Remove(icon);
			}
			IconAsset iconAsset = CreateIcon(icon);
			IconAssets.Add(icon, iconAsset);
			return iconAsset.Sprite;
		}

		internal static void HideTooltip()
		{
			_tooltipOwner?.NotifyTooltipHidden();
			_tooltipOwner = null;
			if ((Object)(object)_tooltipRoot != (Object)null)
			{
				_tooltipRoot.SetActive(false);
			}
		}

		internal static void Dispose()
		{
			HideTooltip();
			if ((Object)(object)_tooltipRoot != (Object)null)
			{
				GameObject? tooltipRoot = _tooltipRoot;
				ClearTooltipReferences();
				DestroyObject((Object?)(object)tooltipRoot);
			}
			else
			{
				ClearTooltipReferences();
			}
			foreach (IconAsset value in IconAssets.Values)
			{
				DestroyObject((Object?)(object)value.Sprite);
				DestroyObject((Object?)(object)value.Texture);
			}
			IconAssets.Clear();
		}

		private static bool ShowTooltip(TooltipTrigger owner, Selectable target, string value, bool usePointerPosition, Vector2 pointerPosition, bool richText, ClanTooltipPlacement placement)
		{
			//IL_0097: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null || string.IsNullOrWhiteSpace(value) || !EnsureTooltip(target))
			{
				return false;
			}
			if ((Object)(object)_tooltipOwner != (Object)(object)owner)
			{
				_tooltipOwner?.NotifyTooltipHidden();
				_tooltipOwner = owner;
			}
			_tooltipText.supportRichText = richText;
			_tooltipText.text = value.Trim();
			SizeTooltip();
			_tooltipRoot.SetActive(true);
			_tooltipRoot.transform.SetAsLastSibling();
			if (placement == ClanTooltipPlacement.LeftOfTarget && TryPlaceTooltipBesideTarget(target))
			{
				return true;
			}
			_tooltipRect.pivot = new Vector2(0f, 1f);
			PlaceAndClampTooltip(usePointerPosition ? (pointerPosition + new Vector2(14f, -14f)) : GetSelectionAnchor(target));
			return true;
		}

		private static bool TryPlaceTooltipBesideTarget(Selectable target)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)target).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (val == null || (Object)(object)_tooltipRect == (Object)null)
			{
				return false;
			}
			val.GetWorldCorners(TooltipWorldCorners);
			Camera? canvasCamera = ClanUiFactory.GetCanvasCamera((Component?)(object)((Component)target).GetComponentInParent<Canvas>());
			Vector2 val2 = RectTransformUtility.WorldToScreenPoint(canvasCamera, TooltipWorldCorners[0]);
			Vector2 val3 = RectTransformUtility.WorldToScreenPoint(canvasCamera, TooltipWorldCorners[1]);
			Vector2 val4 = RectTransformUtility.WorldToScreenPoint(canvasCamera, TooltipWorldCorners[2]);
			Vector2 val5 = RectTransformUtility.WorldToScreenPoint(canvasCamera, TooltipWorldCorners[3]);
			Vector2 val6 = (val2 + val3) * 0.5f;
			Vector2 val7 = (val5 + val4) * 0.5f;
			_tooltipRect.pivot = new Vector2(1f, 0.5f);
			Vector2 val8 = val6 + Vector2.left * 14f;
			SetTooltipScreenPosition(val8);
			Canvas.ForceUpdateCanvases();
			if (IsTooltipInsideHorizontalSafeArea())
			{
				PlaceAndClampTooltip(val8);
				return true;
			}
			_tooltipRect.pivot = new Vector2(0f, 0.5f);
			PlaceAndClampTooltip(val7 + Vector2.right * 14f);
			return true;
		}

		private static bool IsTooltipInsideHorizontalSafeArea()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			_tooltipRect.GetWorldCorners(TooltipWorldCorners);
			Camera? canvasCamera = ClanUiFactory.GetCanvasCamera((Component?)(object)_tooltipCanvas);
			Vector2 val = RectTransformUtility.WorldToScreenPoint(canvasCamera, TooltipWorldCorners[0]);
			Vector2 val2 = RectTransformUtility.WorldToScreenPoint(canvasCamera, TooltipWorldCorners[2]);
			float num = Mathf.Min(val.x, val2.x);
			float num2 = Mathf.Max(val.x, val2.x);
			Rect safeArea = GetSafeArea();
			if (num >= ((Rect)(ref safeArea)).xMin + 6f)
			{
				return num2 <= ((Rect)(ref safeArea)).xMax - 6f;
			}
			return false;
		}

		private static void HideTooltip(TooltipTrigger owner)
		{
			if (!((Object)(object)_tooltipOwner != (Object)(object)owner))
			{
				_tooltipOwner = null;
				if ((Object)(object)_tooltipRoot != (Object)null)
				{
					_tooltipRoot.SetActive(false);
				}
			}
		}

		private static bool IsTooltipRootMissingFor(TooltipTrigger owner)
		{
			if ((Object)(object)_tooltipOwner == (Object)(object)owner)
			{
				if (!((Object)(object)_tooltipRoot == (Object)null) && !((Object)(object)_tooltipRect == (Object)null))
				{
					return (Object)(object)_tooltipText == (Object)null;
				}
				return true;
			}
			return false;
		}

		private static bool EnsureTooltip(Selectable target)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: 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_0188: 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_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			if (!TryResolveTooltipHost(target, out Transform host, out Canvas canvas))
			{
				return false;
			}
			if ((Object)(object)_tooltipRoot != (Object)null && (Object)(object)_tooltipRect != (Object)null && (Object)(object)_tooltipText != (Object)null && (Object)(object)_tooltipHost == (Object)(object)host && (Object)(object)_tooltipCanvas == (Object)(object)canvas)
			{
				return true;
			}
			if ((Object)(object)_tooltipRoot != (Object)null)
			{
				GameObject? tooltipRoot = _tooltipRoot;
				ClearTooltipReferences();
				tooltipRoot.SetActive(false);
				DestroyObject((Object?)(object)tooltipRoot);
			}
			GameObject val = new GameObject("ClanTooltip", new Type[5]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(CanvasGroup),
				typeof(Outline)
			});
			val.transform.SetParent(host, false);
			val.layer = ((Component)host).gameObject.layer;
			RectTransform component = val.GetComponent<RectTransform>();
			RectTransform val2 = (RectTransform)host;
			component.anchorMin = val2.pivot;
			component.anchorMax = val2.pivot;
			component.pivot = new Vector2(0f, 1f);
			component.anchoredPosition = Vector2.zero;
			component.sizeDelta = new Vector2(80f, 28f);
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = new Color(0.045f, 0.04f, 0.035f, 0.96f);
			((Graphic)component2).raycastTarget = false;
			Outline component3 = val.GetComponent<Outline>();
			((Shadow)component3).effectColor = new Color(0.72f, 0.58f, 0.34f, 0.9f);
			((Shadow)component3).effectDistance = new Vector2(1f, -1f);
			((Shadow)component3).useGraphicAlpha = true;
			CanvasGroup component4 = val.GetComponent<CanvasGroup>();
			component4.alpha = 1f;
			component4.interactable = false;
			component4.blocksRaycasts = false;
			component4.ignoreParentGroups = false;
			GameObject val3 = new GameObject("Text", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Text),
				typeof(Shadow)
			});
			val3.transform.SetParent(val.transform, false);
			val3.layer = val.layer;
			Text component5 = val3.GetComponent<Text>();
			component5.font = ClanUiFactory.GetBoldFont();
			component5.fontSize = 14;
			component5.fontStyle = (FontStyle)0;
			component5.alignment = (TextAnchor)3;
			((Graphic)component5).color = new Color(0.96f, 0.92f, 0.82f, 1f);
			component5.horizontalOverflow = (HorizontalWrapMode)0;
			component5.verticalOverflow = (VerticalWrapMode)0;
			component5.supportRichText = false;
			((Graphic)component5).raycastTarget = false;
			Shadow component6 = val3.GetComponent<Shadow>();
			component6.effectColor = new Color(0f, 0f, 0f, 0.75f);
			component6.effectDistance = new Vector2(1f, -1f);
			component6.useGraphicAlpha = true;
			RectTransform component7 = val3.GetComponent<RectTransform>();
			component7.anchorMin = Vector2.zero;
			component7.anchorMax = Vector2.one;
			component7.offsetMin = new Vector2(9f, 5f);
			component7.offsetMax = new Vector2(-9f, -5f);
			val.SetActive(false);
			_tooltipRoot = val;
			_tooltipRect = component;
			_tooltipText = component5;
			_tooltipHost = host;
			_tooltipCanvas = canvas;
			return true;
		}

		private static bool TryResolveTooltipHost(Selectable target, out Transform host, out Canvas canvas)
		{
			try
			{
				GameObject customGUIFront = GUIManager.CustomGUIFront;
				Canvas val = (((Object)(object)customGUIFront != (Object)null) ? customGUIFront.GetComponentInParent<Canvas>() : null);
				if ((Object)(object)customGUIFront != (Object)null && customGUIFront.activeInHierarchy && customGUIFront.transform is RectTransform && (Object)(object)val != (Object)null && ((Behaviour)val).isActiveAndEnabled)
				{
					host = customGUIFront.transform;
					canvas = val;
					return true;
				}
			}
			catch (Exception)
			{
			}
			Canvas componentInParent = ((Component)target).GetComponentInParent<Canvas>();
			if ((Object)(object)componentInParent != (Object)null && ((Component)componentInParent).transform is RectTransform)
			{
				host = ((Component)componentInParent).transform;
				canvas = componentInParent;
				return true;
			}
			host = null;
			canvas = null;
			return false;
		}

		private static void ClearTooltipReferences()
		{
			_tooltipRoot = null;
			_tooltipRect = null;
			_tooltipText = null;
			_tooltipHost = null;
			_tooltipCanvas = null;
		}

		private static void SizeTooltip()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			Rect safeArea = GetSafeArea();
			float num = Mathf.Max(0.01f, _tooltipCanvas.scaleFactor);
			float num2 = Mathf.Max(24f, (((Rect)(ref safeArea)).width - 12f) / num - 18f);
			float num3 = Mathf.Min(320f, num2);
			TextGenerationSettings generationSettings = _tooltipText.GetGenerationSettings(new Vector2(num3, 0f));
			float num4 = Mathf.Max(0.01f, _tooltipText.pixelsPerUnit);
			float num5 = _tooltipText.cachedTextGeneratorForLayout.GetPreferredWidth(_tooltipText.text, generationSettings) / num4;
			if (!IsFinitePositive(num5))
			{
				num5 = 80f;
			}
			float num6 = Mathf.Clamp(num5, 24f, num3);
			TextGenerationSettings generationSettings2 = _tooltipText.GetGenerationSettings(new Vector2(num6, 0f));
			float num7 = _tooltipText.cachedTextGeneratorForLayout.GetPreferredHeight(_tooltipText.text, generationSettings2) / num4;
			if (!IsFinitePositive(num7))
			{
				num7 = (float)_tooltipText.fontSize * 1.4f;
			}
			float num8 = Mathf.Max(20f, (((Rect)(ref safeArea)).height - 12f) / num - 10f);
			float num9 = Mathf.Clamp(num7, (float)_tooltipText.fontSize * 1.2f, Mathf.Min(160f, num8));
			_tooltipRect.sizeDelta = new Vector2(num6 + 18f, num9 + 10f);
		}

		private static Vector2 GetSelectionAnchor(Selectable target)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)target).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if ((Object)(object)val == (Object)null)
			{
				return new Vector2((float)Screen.width * 0.5f, (float)Screen.height * 0.5f);
			}
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			val.GetWorldCorners(array);
			return RectTransformUtility.WorldToScreenPoint(ClanUiFactory.GetCanvasCamera((Component?)(object)((Component)target).GetComponentInParent<Canvas>()), array[2]) + new Vector2(14f, -4f);
		}

		private static void PlaceAndClampTooltip(Vector2 screenPosition)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			SetTooltipScreenPosition(screenPosition);
			Canvas.ForceUpdateCanvases();
			_tooltipRect.GetWorldCorners(TooltipWorldCorners);
			Camera? canvasCamera = ClanUiFactory.GetCanvasCamera((Component?)(object)_tooltipCanvas);
			Vector2 val = RectTransformUtility.WorldToScreenPoint(canvasCamera, TooltipWorldCorners[0]);
			Vector2 val2 = RectTransformUtility.WorldToScreenPoint(canvasCamera, TooltipWorldCorners[2]);
			float num = Mathf.Min(val.x, val2.x);
			float num2 = Mathf.Max(val.x, val2.x);
			float num3 = Mathf.Min(val.y, val2.y);
			float num4 = Mathf.Max(val.y, val2.y);
			Rect safeArea = GetSafeArea();
			float num5 = ((Rect)(ref safeArea)).xMin + 6f;
			float num6 = ((Rect)(ref safeArea)).xMax - 6f;
			float num7 = ((Rect)(ref safeArea)).yMin + 6f;
			float num8 = ((Rect)(ref safeArea)).yMax - 6f;
			Vector2 zero = Vector2.zero;
			if (num < num5)
			{
				zero.x += num5 - num;
			}
			if (num2 + zero.x > num6)
			{
				zero.x += num6 - (num2 + zero.x);
			}
			if (num3 < num7)
			{
				zero.y += num7 - num3;
			}
			if (num4 + zero.y > num8)
			{
				zero.y += num8 - (num4 + zero.y);
			}
			if (((Vector2)(ref zero)).sqrMagnitude > 0.01f)
			{
				SetTooltipScreenPosition(screenPosition + zero);
			}
		}

		private static void SetTooltipScreenPosition(Vector2 screenPosition)
		{
			//IL_001b: 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)
			Transform? tooltipHost = _tooltipHost;
			RectTransform val = (RectTransform)(object)((tooltipHost is RectTransform) ? tooltipHost : null);
			if (val != null)
			{
				Camera canvasCamera = ClanUiFactory.GetCanvasCamera((Component?)(object)_tooltipCanvas);
				Vector2 anchoredPosition = default(Vector2);
				if (RectTransformUtility.ScreenPointToLocalPointInRectangle(val, screenPosition, canvasCamera, ref anchoredPosition))
				{
					_tooltipRect.anchoredPosition = anchoredPosition;
				}
			}
		}

		private static Rect GetSafeArea()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Rect safeArea = Screen.safeArea;
			if (!(((Rect)(ref safeArea)).width > 0f) || !(((Rect)(ref safeArea)).height > 0f))
			{
				return new Rect(0f, 0f, (float)Screen.width, (float)Screen.height);
			}
			return safeArea;
		}

		private static bool IsFinitePositive(float value)
		{
			if (value > 0f && !float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		private static IconAsset CreateIcon(ClanActionIcon icon)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: 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_0186: 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_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: 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_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: 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_024f: 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_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: 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_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: 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_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Expected O, but got Unknown
			//IL_0300: Expected O, but got Unknown
			Color32[] array = (Color32[])(object)new Color32[1024];
			Color32 val = default(Color32);
			((Color32)(ref val))..ctor((byte)18, (byte)16, (byte)14, (byte)235);
			Color32 val2 = (Color32)(icon switch
			{
				ClanActionIcon.Edit => new Color32(byte.MaxValue, (byte)207, (byte)96, byte.MaxValue), 
				ClanActionIcon.Folder => new Color32(byte.MaxValue, (byte)207, (byte)96, byte.MaxValue), 
				ClanActionIcon.Resize => new Color32((byte)248, (byte)248, (byte)244, byte.MaxValue), 
				ClanActionIcon.Collapse => new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue), 
				ClanActionIcon.Expand => new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue), 
				ClanActionIcon.Accept => new Color32((byte)104, (byte)235, (byte)150, byte.MaxValue), 
				ClanActionIcon.Decline => new Color32(byte.MaxValue, (byte)112, (byte)108, byte.MaxValue), 
				_ => throw new ArgumentOutOfRangeException("icon", icon, null), 
			});
			switch (icon)
			{
			case ClanActionIcon.Edit:
				DrawLine(array, new Vector2(7.5f, 7.5f), new Vector2(23f, 23f), 8f, val);
				DrawLine(array, new Vector2(7.5f, 7.5f), new Vector2(23f, 23f), 4.8f, val2);
				DrawLine(array, new Vector2(20.5f, 25.5f), new Vector2(25.5f, 20.5f), 4.5f, val);
				DrawLine(array, new Vector2(20.5f, 25.5f), new Vector2(25.5f, 20.5f), 2f, val2);
				DrawLine(array, new Vector2(5.5f, 5.5f), new Vector2(9f, 6.5f), 3f, val);
				break;
			case ClanActionIcon.Folder:
				DrawFolderIcon(array, val, val2);
				break;
			case ClanActionIcon.Resize:
				DrawResizeIcon(array, 6f, val);
				DrawResizeIcon(array, 3f, val2);
				break;
			case ClanActionIcon.Collapse:
				DrawTriangle(array, pointsUp: true, val2);
				break;
			case ClanActionIcon.Expand:
				DrawTriangle(array, pointsUp: false, val2);
				break;
			case ClanActionIcon.Accept:
				DrawCheckIcon(array, val, val2);
				break;
			case ClanActionIcon.Decline:
				DrawCrossIcon(array, val, val2);
				break;
			}
			Texture2D val3 = new Texture2D(32, 32, (TextureFormat)4, false)
			{
				name = $"ClanActionIcon.{icon}.Texture",
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1,
				hideFlags = (HideFlags)61
			};
			val3.SetPixels32(array);
			val3.Apply(false, true);
			Sprite val4 = Sprite.Create(val3, new Rect(0f, 0f, 32f, 32f), new Vector2(0.5f, 0.5f), 32f, 0u, (SpriteMeshType)0);
			((Object)val4).name = $"ClanActionIcon.{icon}";
			((Object)val4).hideFlags = (HideFlags)61;
			return new IconAsset(val3, val4);
		}

		private static void DrawFolderIcon(Color32[] pixels, Color32 outline, Color32 foreground)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_00bb: 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_00db: 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)
			Vector2[] array = (Vector2[])(object)new Vector2[7]
			{
				new Vector2(6f, 7f),
				new Vector2(26f, 7f),
				new Vector2(26f, 21f),
				new Vector2(16f, 21f),
				new Vector2(13f, 25f),
				new Vector2(6f, 25f),
				new Vector2(6f, 7f)
			};
			for (int i = 1; i < array.Length; i++)
			{
				DrawLine(pixels, array[i - 1], array[i], 6f, outline);
			}
			for (int j = 1; j < array.Length; j++)
			{
				DrawLine(pixels, array[j - 1], array[j], 3f, foreground);
			}
		}

		private static void DrawResizeIcon(Color32[] pixels, float width, Color32 color)
		{
			//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_0026: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			Vector2 start = default(Vector2);
			((Vector2)(ref start))..ctor(7.5f, 24.5f);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(24.5f, 7.5f);
			DrawLine(pixels, start, val, width, color);
			DrawLine(pixels, start, new Vector2(7.5f, 16.5f), width, color);
			DrawLine(pixels, start, new Vector2(15.5f, 24.5f), width, color);
			DrawLine(pixels, val, new Vector2(24.5f, 15.5f), width, color);
			DrawLine(pixels, val, new Vector2(16.5f, 7.5f), width, color);
		}

		private static void DrawCheckIcon(Color32[] pixels, Color32 outline, Color32 foreground)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			Vector2 start = default(Vector2);
			((Vector2)(ref start))..ctor(6.5f, 16f);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(13f, 9.5f);
			Vector2 end = default(Vector2);
			((Vector2)(ref end))..ctor(26f, 23f);
			DrawLine(pixels, start, val, 7f, outline);
			DrawLine(pixels, val, end, 7f, outline);
			DrawLine(pixels, start, val, 4f, foreground);
			DrawLine(pixels, val, end, 4f, foreground);
		}

		private static void DrawCrossIcon(Color32[] pixels, Color32 outline, Color32 foreground)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Vector2 start = default(Vector2);
			((Vector2)(ref start))..ctor(8f, 8f);
			Vector2 start2 = default(Vector2);
			((Vector2)(ref start2))..ctor(8f, 24f);
			Vector2 end = default(Vector2);
			((Vector2)(ref end))..ctor(24f, 8f);
			Vector2 end2 = default(Vector2);
			((Vector2)(ref end2))..ctor(24f, 24f);
			DrawLine(pixels, start, end2, 7f, outline);
			DrawLine(pixels, start2, end, 7f, outline);
			DrawLine(pixels, start, end2, 4f, foreground);
			DrawLine(pixels, start2, end, 4f, foreground);
		}

		private static void DrawTriangle(Color32[] pixels, bool pointsUp, Color32 color)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			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++)
				{
					BlendPixel(pixels, j, i, color, 1f);
				}
			}
		}

		private static void DrawLine(Color32[] pixels, Vector2 start, Vector2 end, float width, Color32 color)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_007b: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			float radius = width * 0.5f;
			float minimumX = Mathf.Min(start.x, end.x) - radius - 1f;
			float maximumX = Mathf.Max(start.x, end.x) + radius + 1f;
			float minimumY = Mathf.Min(start.y, end.y) - radius - 1f;
			float maximumY = Mathf.Max(start.y, end.y) + radius + 1f;
			Vector2 segment = end - start;
			float segmentLengthSquared = ((Vector2)(ref segment)).sqrMagnitude;
			ForEachPixel(minimumX, maximumX, minimumY, maximumY, delegate(int x, int y)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: 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_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor((float)x + 0.5f, (float)y + 0.5f);
				float num = ((segmentLengthSquared > 0.0001f) ? Mathf.Clamp01(Vector2.Dot(val - start, segment) / segmentLengthSquared) : 0f);
				float num2 = Vector2.Distance(val, start + segment * num);
				BlendPixel(pixels, x, y, color, Mathf.Clamp01(radius + 0.5f - num2));
			});
		}

		private static void ForEachPixel(float minimumX, float maximumX, float minimumY, float maximumY, Action<int, int> action)
		{
			int num = Mathf.Clamp(Mathf.FloorToInt(minimumX), 0, 31);
			int num2 = Mathf.Clamp(Mathf.CeilToInt(maximumX), 0, 31);
			int num3 = Mathf.Clamp(Mathf.FloorToInt(minimumY), 0, 31);
			int num4 = Mathf.Clamp(Mathf.CeilToInt(maximumY), 0, 31);
			for (int i = num3; i <= num4; i++)
			{
				for (int j = num; j <= num2; j++)
				{
					action(j, i);
				}
			}
		}

		private static void BlendPixel(Color32[] pixels, int x, int y, Color32 source, float coverage)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_0065: 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_008b: 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_00b1: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			if (!(coverage <= 0f))
			{
				int num = y * 32 + x;
				Color32 val = pixels[num];
				float num2 = (float)(int)source.a / 255f * coverage;
				float num3 = (float)(int)val.a / 255f;
				float num4 = num2 + num3 * (1f - num2);
				if (!(num4 <= 0f))
				{
					float num5 = num2 / num4;
					float num6 = num3 * (1f - num2) / num4;
					pixels[num] = new Color32((byte)Mathf.Clamp(Mathf.RoundToInt((float)(int)source.r * num5 + (float)(int)val.r * num6), 0, 255), (byte)Mathf.Clamp(Mathf.RoundToInt((float)(int)source.g * num5 + (float)(int)val.g * num6), 0, 255), (byte)Mathf.Clamp(Mathf.RoundToInt((float)(int)source.b * num5 + (float)(int)val.b * num6), 0, 255), (byte)Mathf.Clamp(Mathf.RoundToInt(num4 * 255f), 0, 255));
				}
			}
		}

		private static void DestroyObject(Object? value)
		{
			if (!(value == (Object)null))
			{
				if (Application.isPlaying)
				{
					Object.Destroy(value);
				}
				else
				{
					Object.DestroyImmediate(value);
				}
			}
		}
	}
	internal readonly struct ClanRecentPlayerEntry
	{
		internal ClanPlayerRef Player { get; }

		internal bool IsOnline { get; }

		internal long LastSeenUtcTicks { get; }

		internal ClanRecentPlayerEntry(ClanPlayerRef player, bool isOnline, long lastSeenUtcTicks)
		{
			Player = player;
			IsOnline = isOnline;
			LastSeenUtcTicks = lastSeenUtcTicks;
		}
	}
	internal static class ClanRecentPlayers
	{
		private sealed class RecentPlayersYaml
		{
			[YamlMember(Alias = "format_version", Order = 1)]
			public int FormatVersion { get; set; }

			[YamlMember(Alias = "players", Order = 2)]
			public List<RecentPlayerYaml>? Players { get; set; }
		}

		private sealed class RecentPlayerYaml
		{
			[YamlMember(Alias = "platform_id", Order = 1)]
			public string? PlatformId { get; set; }

			[YamlMember(Alias = "player_id", Order = 2)]
			public long PlayerId { get; set; }

			[YamlMember(Alias = "name", Order = 3)]
			public string? Name { get; set; }

			[YamlMember(Alias = "last_seen_utc", Order = 4)]
			public string? LastSeenUtc { get; set; }
		}

		private sealed class StoredRecentPlayer
		{
			internal ClanPlayerRef Player;

			internal long LastSeenUtcTicks;

			internal bool IsOnline;
		}

		private const int FormatVersion = 1;

		private const int MaximumPlayers = 4096;

		private const int MaximumSaveBytes = 4194304;

		private static readonly TimeSpan RecentLifetime = TimeSpan.FromDays(28.0);

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

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

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

		private static readonly TimeSpan PruneInterval = TimeSpan.FromMinutes(5.0);

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

		private static readonly UTF8Encoding StrictUtf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

		private static readonly ISerializer YamlSerializer = new SerializerBuilder().DisableAliases().WithIndentedSequences().Build();

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

		private static bool _initialized;

		private static ZNet? _loadedSession;

		private static long _loadedWorldUid;

		private static string? _loadedSaveFile;

		private static bool _dirty;

		private static bool _saveFailed;

		private static bool _primaryRecoveryRequired;

		private static bool _capacityWarningLogged;

		private static DateTime _nextPollUtc = DateTime.MinValue;

		private static DateTime _nextPruneUtc = DateTime.MinValue;

		private static DateTime _nextLoadAttemptUtc = DateTime.MinValue;

		private static DateTime _saveAfterUtc = DateTime.MaxValue;

		internal static void Init()
		{
			if (_initialized)
			{
				Dispose();
			}
			_initialized = true;
			ResetMemory();
		}

		internal static void Dispose()
		{
			if (_initialized)
			{
				CloseLoadedSession(DateTime.UtcNow, bypassSaveRetryDelay: true);
				_initialized = false;
				ResetMemory();
			}
		}

		internal static void Tick()
		{
			if (!_initialized)
			{
				Init();
			}
			DateTime utcNow = DateTime.UtcNow;
			if (EnsureServerSession(utcNow))
			{
				if (utcNow >= _nextPollUtc)
				{
					_nextPollUtc = utcNow.Add(PollInterval);
					PollOnlinePlayers(utcNow);
				}
				if (utcNow >= _nextPruneUtc)
				{
					_nextPruneUtc = utcNow.Add(PruneInterval);
					RefreshOnlineLastSeen(utcNow);
					PruneExpiredPlayers(utcNow);
				}
				if (_dirty && utcNow >= _saveAfterUtc)
				{
					TrySave(utcNow, force: false);
				}
			}
		}

		internal static IReadOnlyList<ClanRecentPlayerEntry> GetRecentPlayers()
		{
			DateTime utcNow = DateTime.UtcNow;
			if (!_initialized || !EnsureServerSession(utcNow))
			{
				return Array.Empty<ClanRecentPlayerEntry>();
			}
			List<ClanRecentPlayerEntry> list = new List<ClanRecentPlayerEntry>(PlayersById.Count);
			foreach (StoredRecentPlayer value in PlayersById.Values)
			{
				if (value.IsOnline || IsRecent(value, utcNow))
				{
					list.Add(new ClanRecentPlayerEntry(value.Player, value.IsOnline, Math.Min(value.LastSeenUtcTicks, utcNow.Ticks)));
				}
			}
			list.Sort(CompareEntries);
			return list;
		}

		internal static bool TryGetPlayer(string? playerId, out ClanPlayerRef player)
		{
			player = default(ClanPlayerRef);
			string text = ClanDataRules.NormalizePlayerKey(playerId);
			if (text.Length == 0)
			{
				return false;
			}
			DateTime utcNow = DateTime.UtcNow;
			if (!_initialized || !EnsureServerSession(utcNow) || !PlayersById.TryGetValue(text, out StoredRecentPlayer value) || (!value.IsOnline && !IsRecent(value, utcNow)))
			{
				return false;
			}
			player = value.Player;
			return player.IsValid;
		}

		internal static void RememberPlayer(ClanPlayerRef player)
		{
			if (player.IsValid)
			{
				DateTime utcNow = DateTime.UtcNow;
				if (_initialized && EnsureServerSession(utcNow))
				{
					TryUpsertOnlinePlayer(player, utcNow);
				}
			}
		}

		internal static void MarkPlayerOffline(ClanPlayerRef player)
		{
			if (player.IsValid)
			{
				DateTime utcNow = DateTime.UtcNow;
				if (_initialized && EnsureServerSession(utcNow) && PlayersById.TryGetValue(player.Id, out StoredRecentPlayer value) && value.IsOnline)
				{
					value.IsOnline = false;
					value.LastSeenUtcTicks = utcNow.Ticks;
					MarkDirty(utcNow);
				}
			}
		}

		private static bool EnsureServerSession(DateTime nowUtc)
		{
			ZNet instance = ZNet.instance;
			World world = ZNet.World;
			if ((Object)(object)instance == (Object)null || !instance.IsServer() || world == null)
			{
				if (_loadedSaveFile != null)
				{
					CloseLoadedSession(nowUtc);
				}
				return false;
			}
			long uid = world.m_uid;
			if (_loadedSession == instance && _loadedWorldUid == uid && _loadedSaveFile != null)
			{
				return true;
			}
			if (nowUtc < _nextLoadAttemptUtc)
			{
				return false;
			}
			if (!CloseLoadedSession(nowUtc))
			{
				return false;
			}
			_loadedSession = instance;
			_loadedWorldUid = uid;
			_loadedSaveFile = ResolveSaveFile();
			try
			{
				LoadGlobalSave(nowUtc);
			}
			catch (Exception ex) when (IsSaveAccessError(ex))
			{
				string loadedSaveFile = _loadedSaveFile;
				ResetMemory();
				_nextLoadAttemptUtc = nowUtc.Add(SaveRetryDelay);
				ClanPlugin.ClanLogger.LogWarning((object)("Could not read recent-player data from '" + loadedSaveFile + "'. The file was left unchanged and loading will be retried: " + ex.Message));
				return false;
			}
			_nextLoadAttemptUtc = DateTime.MinValue;
			_nextPollUtc = DateTime.MinValue;
			_nextPruneUtc = nowUtc.Add(PruneInterval);
			return true;
		}

		private static bool CloseLoadedSession(DateTime nowUtc, bool bypassSaveRetryDelay = false)
		{
			if (_loadedSaveFile != null)
			{
				MarkAllOffline(nowUtc);
				if (!TrySave(nowUtc, force: true, bypassSaveRetryDelay))
				{
					return false;
				}
			}
			ResetMemory();
			return true;
		}

		private static void PollOnlinePlayers(DateTime nowUtc)
		{
			Dictionary<string, ClanPlayerRef> dictionary = new Dictionary<string, ClanPlayerRef>(StringComparer.Ordinal);
			foreach (ClanPlayerRef onlinePlayerRef in ClanIdentity.GetOnlinePlayerRefs())
			{
				if (onlinePlayerRef.IsValid)
				{
					dictionary[onlinePlayerRef.Id] = onlinePlayerRef;
				}
			}
			foreach (ClanPlayerRef value in dictionary.Values)
			{
				if (!TryUpsertOnlinePlayer(value, nowUtc) && !_capacityWarningLogged)
				{
					_capacityWarningLogged = true;
					ClanPlugin.ClanLogger.LogWarning((object)($"Recent-player storage reached its {4096}-player limit; " + "additional online players cannot be recorded until an offline entry expires."));
				}
			}
			foreach (StoredRecentPlayer value2 in PlayersById.Values)
			{
				if (value2.IsOnline && !dictionary.ContainsKey(value2.Player.Id))
				{
					value2.IsOnline = false;
					value2.LastSeenUtcTicks = nowUtc.Ticks;
					MarkDirty(nowUtc);
				}
			}
			if (PlayersById.Count < 4096)
			{
				_capacityWarningLogged = false;
			}
		}

		private static bool TryUpsertOnlinePlayer(ClanPlayerRef player, DateTime nowUtc)
		{
			if (!PlayersById.TryGetValue(player.Id, out StoredRecentPlayer value))
			{
				if (!MakeRoomForPlayer(nowUtc))
				{
					return false;
				}
				PlayersById.Add(player.Id, new StoredRecentPlayer
				{
					Player = player,
					LastSeenUtcTicks = nowUtc.Ticks,
					IsOnline = true
				});
				MarkDirty(nowUtc);
				return true;
			}
			bool flag = false;
			if (!StringComparer.Ordinal.Equals(value.Player.Name, player.Name))
			{
				value.Player = player;
				flag = true;
			}
			if (!value.IsOnline)
			{
				value.IsOnline = true;
				value.LastSeenUtcTicks = nowUtc.Ticks;
				flag = true;
			}
			if (flag)
			{
				MarkDirty(nowUtc);
			}
			return true;
		}

		private static void RefreshOnlineLastSeen(DateTime nowUtc)
		{
			bool flag = false;
			foreach (StoredRecentPlayer value in PlayersById.Values)
			{
				if (value.IsOnline && value.LastSeenUtcTicks != nowUtc.Ticks)
				{
					value.LastSeenUtcTicks = nowUtc.Ticks;
					flag = true;
				}
			}
			if (flag)
			{
				MarkDirty(nowUtc);
			}
		}

		private static void MarkAllOffline(DateTime nowUtc)
		{
			bool flag = false;
			foreach (StoredRecentPlayer value in PlayersById.Values)
			{
				if (value.IsOnline)
				{
					value.IsOnline = false;
					value.LastSeenUtcTicks = nowUtc.Ticks;
					flag = true;
				}
			}
			if (flag)
			{
				MarkDirty(nowUtc);
			}
		}

		private static bool MakeRoomForPlayer(DateTime nowUtc)
		{
			PruneExpiredPlayers(nowUtc);
			if (PlayersById.Count < 4096)
			{
				return true;
			}
			StoredRecentPlayer storedRecentPlayer = null;
			foreach (StoredRecentPlayer value in PlayersById.Values)
			{
				if (!value.IsOnline && (storedRecentPlayer == null || CompareOldest(value, storedRecentPlayer) < 0))
				{
					storedRecentPlayer = value;
				}
			}
			if (storedRecentPlayer == null)
			{
				return false;
			}
			PlayersById.Remove(storedRecentPlayer.Player.Id);
			MarkDirty(nowUtc);
			return true;
		}

		private static int CompareOldest(StoredRecentPlayer left, StoredRecentPlayer right)
		{
			int num = left.LastSeenUtcTicks.CompareTo(right.LastSeenUtcTicks);
			if (num == 0)
			{
				return StringComparer.Ordinal.Compare(left.Player.Id, right.Player.Id);
			}
			return num;
		}

		private static void PruneExpiredPlayers(DateTime nowUtc)
		{
			List<string> list = null;
			bool flag = false;
			foreach (StoredRecentPlayer value in PlayersById.Values)
			{
				if (value.LastSeenUtcTicks > nowUtc.Ticks)
				{
					value.LastSeenUtcTicks = nowUtc.Ticks;
					flag = true;
				}
				if (!value.IsOnline && !IsRecent(value, nowUtc))
				{
					if (list == null)
					{
						list = new List<string>();
					}
					list.Add(value.Player.Id);
				}
			}
			if (list == null)
			{
				if (flag)
				{
					MarkDirty(nowUtc);
				}
				return;
			}
			foreach (string item in list)
			{
				PlayersById.Remove(item);
			}
			MarkDirty(nowUtc);
		}

		private static bool IsRecent(StoredRecentPlayer player, DateTime nowUtc)
		{
			long num = Math.Min(player.LastSeenUtcTicks, nowUtc.Ticks);
			DateTime minValue = DateTime.MinValue;
			if (num > minValue.Ticks)
			{
				long num2 = nowUtc.Ticks - num;
				TimeSpan recentLifetime = RecentLifetime;
				return num2 <= recentLifetime.Ticks;
			}
			return false;
		}

		private static int CompareEntries(ClanRecentPlayerEntry left, ClanRecentPlayerEntry right)
		{
			int num = right.IsOnline.CompareTo(left.IsOnline);
			if (num != 0)
			{
				return num;
			}
			int num2 = right.LastSeenUtcTicks.CompareTo(left.LastSeenUtcTicks);
			if (num2 != 0)
			{
				return num2;
			}
			int num3 = StringComparer.OrdinalIgnoreCase.Compare(left.Player.Name, right.Player.Name);
			if (num3 == 0)
			{
				return StringComparer.Ordinal.Compare(left.Player.Id, right.Player.Id);
			}
			return num3;
		}

		private static void LoadGlobalSave(DateTime nowUtc)
		{
			PlayersById.Clear();
			_dirty = false;
			_saveFailed = false;
			_primaryRecoveryRequired = false;
			_saveAfterUtc = DateTime.MaxValue;
			string loadedSaveFile = _loadedSaveFile;
			string text = loadedSaveFile + ".bak";
			if (TryLoadSave(loadedSaveFile, nowUtc, out Dictionary<string, StoredRecentPlayer> players, out bool needsRewrite, out Exception error))
			{
				ReplacePlayers(players);
				PruneExpiredPlayers(nowUtc);
				if (needsRewrite)
				{
					MarkDirty(nowUtc);
				}
				return;
			}
			if (error != null)
			{
				string text2 = TryQuarantine(loadedSaveFile);
				_primaryRecoveryRequired = text2.Length == 0 && File.Exists(loadedSaveFile);
				ClanPlugin.ClanLogger.LogWarning((object)("Recent-player save '" + loadedSaveFile + "' was invalid and " + ((text2.Length == 0) ? "could not be quarantined" : ("was moved to '" + text2 + "'")) + ": " + error.Message));
			}
			if (TryLoadSave(text, nowUtc, out players, out bool _, out Exception error2))
			{
				ReplacePlayers(players);
				if (_primaryRecoveryRequired)
				{
					ClanPlugin.ClanLogger.LogWarning((object)("Loaded recent-player data from the validated backup '" + text + "', but the invalid primary could not be quarantined. Recovery will be retried without overwriting the valid backup."));
					ScheduleSaveRetry(nowUtc);
				}
				else
				{
					try
					{
						WriteAtomically(loadedSaveFile, SerializePlayers());
						ClanPlugin.ClanLogger.LogWarning((object)("Restored recent-player data from the validated backup '" + text + "'."));
					}
					catch (Exception ex)
					{
						ClanPlugin.ClanLogger.LogWarning((object)("Loaded recent-player backup '" + text + "', but failed to restore the primary save: " + ex.Message));
						ScheduleSaveRetry(nowUtc);
					}
				}
				PruneExpiredPlayers(nowUtc);
				return;
			}
			if (error2 != null)
			{
				string text3 = TryQuarantine(text);
				ClanPlugin.ClanLogger.LogWarning((object)("Recent-player backup '" + text + "' was invalid and " + ((text3.Length == 0) ? "could not be quarantined" : ("was moved to '" + text3 + "'")) + ": " + error2.Message));
			}
			PlayersById.Clear();
			_dirty = false;
			_saveAfterUtc = DateTime.MaxValue;
		}

		private static bool TryLoadSave(string path, DateTime nowUtc, out Dictionary<string, StoredRecentPlayer>? players, out bool needsRewrite, out Exception? error)
		{
			players = null;
			needsRewrite = false;
			error = null;
			try
			{
				FileInfo fileInfo = new FileInfo(path);
				if (fileInfo.Length < 0 || fileInfo.Length > 4194304)
				{
					throw new InvalidDataException($"Recent-player save exceeds the {4194304}-byte limit.");
				}
				byte[] array = File.ReadAllBytes(path);
				if (array.Length > 4194304)
				{
					throw new InvalidDataException($"Recent-player save exceeds the {4194304}-byte limit.");
				}
				players = ParseSave(array, nowUtc, out needsRewrite);
				return true;
			}
			catch (FileNotFoundException)
			{
				return false;
			}
			catch (DirectoryNotFoundException)
			{
				return false;
			}
			catch (Exception ex3) when (IsInvalidSaveContent(ex3))
			{
				error = ex3;
				return false;
			}
		}

		private static bool IsInvalidSaveContent(Exception error)
		{
			if (error is InvalidDataException || error is DecoderFallbackException || error is YamlException)
			{
				return true;
			}
			return false;
		}

		private static bool IsSaveAccessError(Exception error)
		{
			if (error is IOException || error is UnauthorizedAccessException || error is SecurityException)
			{
				return true;
			}
			return false;
		}

		private static Dictionary<string, StoredRecentPlayer> ParseSave(byte[] bytes, DateTime nowUtc, out bool needsRewrite)
		{
			needsRewrite = false;
			string input = StrictUtf8.GetString(bytes);
			RecentPlayersYaml recentPlayersYaml = YamlDeserializer.Deserialize<RecentPlayersYaml>(input);
			if (recentPlayersYaml == null)
			{
				throw new InvalidDataException("Recent-player save is empty.");
			}
			if (recentPlayersYaml.FormatVersion != 1)
			{
				throw new InvalidDataException($"Recent-player format version {recentPlayersYaml.FormatVersion} is unsupported; " + $"only version {1} is accepted.");
			}
			List<RecentPlayerYaml> list = recentPlayersYaml.Players ?? throw new InvalidDataException("Recent-player save is missing the players list.");
			if (list.Count > 4096)
			{
				throw new InvalidDataException($"Recent-player count exceeds the {4096}-player limit.");
			}
			Dictionary<string, StoredRecentPlayer> dictionary = new Dictionary<string, StoredRecentPlayer>(list.Count, StringComparer.Ordinal);
			bool flag = false;
			int num = 0;
			while (num < list.Count)
			{
				RecentPlayerYaml obj = list[num] ?? throw new InvalidDataException($"Recent-player entry {num} cannot be null.");
				string platformId = ClanDataRules.RequirePlatformId(obj.PlatformId, $"recent player {num} platform_id");
				long playerId = ClanDataRules.RequireCharacterPlayerId(obj.PlayerId, $"recent player {num} player_id");
				if (obj.Name == null)
				{
					throw new InvalidDataException($"Recent-player entry {num} is missing name.");
				}
				string name = ClanDataRules.RequireText(obj.Name, 64, $"recent player {num} name");
				ClanPlayerRef player = new ClanPlayerRef(platformId, playerId, name);
				string text = ClanDataRules.RequireText(obj.LastSeenUtc, 64, "recent player '" + player.Id + "' last_seen_utc", allowEmpty: false);
				if (DateTime.TryParseExact(text, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result) && result.Kind == DateTimeKind.Utc && StringComparer.Ordinal.Equals(text, result.ToString("O", CultureInfo.InvariantCulture)))
				{
					long ticks = result.Ticks;
					DateTime minValue = DateTime.MinValue;
					if (ticks > minValue.Ticks)
					{
						if (dictionary.ContainsKey(player.Id))
						{
							throw new InvalidDataException("Recent-player save contains duplicate identity '" + player.Id + "'.");
						}
						if (result.Ticks > nowUtc.Ticks)
						{
							result = nowUtc;
							flag = true;
							needsRewrite = true;
						}
						dictionary.Add(player.Id, new StoredRecentPlayer
						{
							Player = player,
							LastSeenUtcTicks = result.Ticks,
							IsOnline = false
						});
						num++;
						continue;
					}
				}
				throw new InvalidDataException("Recent player '" + player.Id + "' has an invalid last-seen timestamp.");
			}
			if (flag)
			{
				ClanPlugin.ClanLogger.LogWarning((object)"Recent-player save contained future last-seen timestamps; they were clamped to the current UTC time.");
			}
			return dictionary;
		}

		private static void ReplacePlayers(Dictionary<string, StoredRecentPlayer> loaded)
		{
			PlayersById.Clear();
			foreach (KeyValuePair<string, StoredRecentPlayer> item in loaded)
			{
				PlayersById.Add(item.Key, item.Value);
			}
			_dirty = false;
			_saveAfterUtc = DateTime.MaxValue;
		}

		private static bool TrySave(DateTime nowUtc, bool force, bool bypassRetryDelay = false)
		{
			if (!_dirty || _loadedSaveFile == null)
			{
				return true;
			}
			if (nowUtc < _saveAfterUtc && (!force || (_saveFailed && !bypassRetryDelay)))
			{
				return false;
			}
			try
			{
				if (_primaryRecoveryRequired && File.Exists(_loadedSaveFile))
				{
					if (TryQuarantine(_loadedSaveFile).Length == 0 && File.Exists(_loadedSaveFile))
					{
						throw new IOException("The invalid recent-player primary save could not be quarantined.");
					}
					_primaryRecoveryRequired = false;
				}
				WriteAtomically(_loadedSaveFile, SerializePlayers());
				_dirty = false;
				_saveFailed = false;
				_saveAfterUtc = DateTime.MaxValue;
				return true;
			}
			catch (Exception ex)
			{
				_saveFailed = true;
				_saveAfterUtc = nowUtc.Add(SaveRetryDelay);
				ClanPlugin.ClanLogger.LogWarning((object)("Failed to save global recent-player data: " + ex.Message));
				return false;
			}
		}

		private static byte[] SerializePlayers()
		{
			if (PlayersById.Count > 4096)
			{
				throw new InvalidDataException($"Recent-player count exceeds the {4096}-player limit.");
			}
			List<StoredRecentPlayer> list = new List<StoredRecentPlayer>(PlayersById.Values);
			list.Sort((StoredRecentPlayer left, StoredRecentPlayer right) => StringComparer.Ordinal.Compare(left.Player.Id, right.Player.Id));
			List<RecentPlayerYaml> list2 = new List<RecentPlayerYaml>(list.Count);
			RecentPlayersYaml graph = new RecentPlayersYaml
			{
				FormatVersion = 1,
				Players = list2
			};
			foreach (StoredRecentPlayer item in list)
			{
				string platformId = ClanDataRules.RequirePlatformId(item.Player.PlatformId);
				long playerId = ClanDataRules.RequireCharacterPlayerId(item.Player.CharacterPlayerId);
				string name = ClanDataRules.RequireText(item.Player.Name, 64, "player name");
				long lastSeenUtcTicks = item.LastSeenUtcTicks;
				DateTime minValue = DateTime.MinValue;
				if (lastSeenUtcTicks > minValue.Ticks)
				{
					long lastSeenUtcTicks2 = item.LastSeenUtcTicks;
					minValue = DateTime.MaxValue;
					if (lastSeenUtcTicks2 <= minValue.Ticks)
					{
						list2.Add(new RecentPlayerYaml
						{
							PlatformId = platformId,
							PlayerId = playerId,
							Name = name,
							LastSeenUtc = new DateTime(item.LastSeenUtcTicks, DateTimeKind.Utc).ToString("O", CultureInfo.InvariantCulture)
						});
						continue;
					}
				}
				throw new InvalidDataException("Recent player '" + item.Player.Id + "' has an invalid last-seen timestamp.");
			}
			string text = YamlSerializer.Serialize(graph).Replace("\r\n", "\n").Replace('\r', '\n');
			if (!text.EndsWith("\n", StringComparison.Ordinal))
			{
				text += "\n";
			}
			byte[] bytes = StrictUtf8.GetBytes(text);
			if (bytes.Length > 4194304)
			{
				throw new InvalidDataException($"Recent-player save exceeds the {4194304}-byte limit.");
			}
			return bytes;
		}

		private static void WriteAtomically(string saveFile, byte[] bytes)
		{
			string? directoryName = Path.GetDirectoryName(saveFile);
			if (string.IsNullOrWhiteSpace(directoryName))
			{
				throw new InvalidOperationException("Recent-player save directory is invalid.");
			}
			Directory.CreateDirectory(directoryName);
			string text = saveFile + ".tmp-" + Guid.NewGuid().ToString("N");
			try
			{
				using (FileStream fileStream = new FileStream(text, FileMode.CreateNew, FileAccess.Write, FileShare.None))
				{
					fileStream.Write(bytes, 0, bytes.Length);
					fileStream.Flush(flushToDisk: true);
				}
				if (File.Exists(saveFile))
				{
					string destinationBackupFileName = saveFile + ".bak";
					File.Replace(text, saveFile, destinationBackupFileName, ignoreMetadataErrors: true);
				}
				else
				{
					File.Move(text, saveFile);
				}
			}
			finally
			{
				try
				{
					if (File.Exists(text))
					{
						File.Delete(text);
					}
				}
				catch (Exception ex)
				{
					ClanPlugin.ClanLogger.LogWarning((object)("Failed to clean temporary recent-player save '" + text + "': " + ex.Message));
				}
			}
		}

		private static string TryQuarantine(string path)
		{
			string text = DateTime.UtcNow.ToString("yyyyMMddHHmmss", CultureInfo.InvariantCulture);
			for (int i = 0; i < 10; i++)
			{
				string text2 = path + ".unsupported-or-corrupt-" + text + "-" + Guid.NewGuid().ToString("N");
				try
				{
					File.Move(path, text2);
					return text2;
				}
				catch (FileNotFoundException)
				{
					return "";
				}
				catch (DirectoryNotFoundException)
				{
					return "";
				}
				catch (IOException) when (File.Exists(path) && File.Exists(text2))
				{
				}
			}
			ClanPlugin.ClanLogger.LogWarning((object)("Could not allocate a quarantine path for recent-player save '" + path + "'."));
			return "";
		}

		private static string ResolveSaveFile()
		{
			return Path.Combine(ClanPlugin.DataDirectory, "recent-players.yml");
		}

		private static void MarkDirty(DateTime nowUtc)
		{
			_dirty = true;
			if (!_saveFailed)
			{
				DateTime dateTime = nowUtc.Add(SaveDebounce);
				if (_saveAfterUtc == DateTime.MaxValue || dateTime < _saveAfterUtc)
				{
					_saveAfterUtc = dateTime;
				}
			}
		}

		private static void ScheduleSaveRetry(DateTime nowUtc)
		{
			_dirty = true;
			_saveFailed = true;
			_saveAfterUtc = nowUtc.Add(SaveRetryDelay);
		}

		private static void ResetMemory()
		{
			PlayersById.Clear();
			_loadedSession = null;
			_loadedWorldUid = 0L;
			_loadedSaveFile = null;
			_dirty = false;
			_saveFailed = false;
			_primaryRecoveryRequired = false;
			_capacityWarningLogged = false;
			_nextPollUtc = DateTime.MinValue;
			_nextPruneUtc = DateTime.MinValue;
			_nextLoadAttemptUtc = DateTime.MinValue;
			_saveAfterUtc = DateTime.MaxValue;
		}
	}
	internal static class ClanPanelController
	{
		private enum PanelTab
		{
			Members,
			Players
		}

		private enum ConfirmAction
		{
			None,
			RejectApplication,
			Kick,
			TransferLeadership,
			Leave
		}

		private const float PanelWidth = 790f;

		private const float PanelHeight = 520f;

		private const float PreferredPanelScale = 2f;

		private const float SafeAreaGap = 8f;

		private const float MutationDirectoryRefreshDelay = 2.1f;

		private const float LeftPaneWidth = 358f;

		private const float RightPaneWidth = 408f;

		private const float RightContentWidth = 412f;

		private const float PanelScrollbarWidth = 2f;

		private const float ScrollOverflowEpsilon = 0.5f;

		private static readonly Color PanelColor = new Color(0.32f, 0.2f, 0.11f, 0.98f);

		private static readonly Color SectionColor = new Color(0f, 0f, 0f, 0.08f);

		private static readonly Color RowColor = new Color(0f, 0f, 0f, 0.18f);

		private static readonly Color AlternateRowColor = new Color(0f, 0f, 0f, 0.1f);

		private static readonly Color ButtonColor = new Color(0.78f, 0.78f, 0.78f, 0.96f);

		private static readonly Color InactiveToggleButtonColor = new Color(0.5f, 0.5f, 0.5f, 0.95f);

		private static readonly Color ActiveButtonColor = new Color(1f, 1f, 1f, 0.95f);

		private static readonly Color DisabledButtonColor = new Color(0.25f, 0.25f, 0.25f, 0.72f);

		private static readonly Color DangerColor = new Color(0.9f, 0.42f, 0.36f, 0.96f);

		private static readonly Color ActiveGuestBadgeColor = new Color(0.55f, 0.31f, 0.08f, 0.98f);

		private static readonly Color PickerButtonColor = new Color(0.18f, 0.18f, 0.18f, 0.26f);

		private static readonly Color ActivePickerButtonColor = new Color(0.55f, 0.31f, 0.08f, 0.72f);

		private static readonly Color DisabledPickerButtonColor = new Color(0f, 0f, 0f, 0.08f);

		private static readonly Color InactiveButtonLabelColor = Color.gray;

		private static readonly Color DisabledButtonLabelColor = new Color(0.4f, 0.4f, 0.4f, 0.9f);

		private static readonly Color MutedColor = new Color(0.853f, 0.725f, 0.533f, 1f);

		private static readonly Color AccentColor = new Color(1f, 0.631f, 0.235f, 1f);

		private static GameObject? _root;

		private static RectTransform? _rootRect;

		private static RectTransform? _overlayRoot;

		private static Button? _profileActionButton;

		private static Button? _membersTabButton;

		private static Text? _membersTabButtonLabel;

		private static Button? _playersTabButton;

		private static InputField? _clanSearchInput;

		private static InputField? _playerSearchInput;

		private static ScrollRect? _clanScroll;

		private static RectTransform? _clanScrollContent;

		private static ScrollRect? _peopleScroll;

		private static RectTransform? _peopleScrollContent;

		private static GameObject? _editorErrorBanner;

		private static Text? _editorErrorLabel;

		private static ClanClientSnapshot _snapshot = new ClanClientSnapshot();

		private static ClanDirectorySnapshot _directory = new ClanDirectorySnapshot();

		private static PanelTab _tab = PanelTab.Members;

		private static ConfirmAction _confirmAction;

		private static string _confirmTarget = "";

		private static float _clanScrollPosition = 1f;

		private static float _rightScrollPosition = 1f;

		private static float _emblemScrollPosition = 1f;

		private static string _clanSearchQuery = "";

		private static string _playerSearchQuery = "";

		private static bool _resetClanScrollOnNextPopulate;

		private static bool _clanRowsDirty;

		private static bool _peopleRowsDirty;

		private static bool _positionValid;

		private static Rect _positionSafeArea;

		private static Rect _positionOverlayBounds;

		private static bool _editorOpen;

		private static bool _editorCreating;

		private static bool _editorSubmissionPending;

		private static long _editorSubmissionRequestId;

		private static string _draftName = "";

		private static string _draftDescription = "";

		private static string _draftEmblemKey = "";

		private static string _editorError = "";

		private static float _directoryRefreshAt = float.PositiveInfinity;

		private static bool _directoryPendingAtLastBuild;

		public static bool IsOpen
		{
			get
			{
				if ((Object)(object)_root != (Object)null)
				{
					return _root.activeSelf;
				}
				return false;
			}
		}

		public static bool CapturesGameplayInput
		{
			get
			{
				if ((Object)(object)_root != (Object)null)
				{
					return _root.activeInHierarchy;
				}
				return false;
			}
		}

		public static bool OwnsSelectedControl
		{
			get
			{
				EventSystem current = EventSystem.current;
				if (IsOpen && (Object)(object)current != (Object)null)
				{
					return IsOwnedControl(current.currentSelectedGameObject);
				}
				return false;
			}
		}

		public static bool OwnsFocusedTextInput
		{
			get
			{
				EventSystem current = EventSystem.current;
				if (!IsOpen || (Object)(object)current == (Object)null)
				{
					return false;
				}
				GameObject currentSelectedGameObject = current.currentSelectedGameObject;
				if ((Object)(object)currentSelectedGameObject == (Object)null || !IsOwnedControl(currentSelectedGameObject))
				{
					return false;
				}
				InputField component = currentSelectedGameObject.GetComponent<InputField>();
				if ((Object)(object)component != (Object)null)
				{
					return component.isFocused;
				}
				return false;
			}
		}

		public static event Action<bool>? OpenStateChanged;

		private static bool IsOwnedControl(GameObject? selected)
		{
			if ((Object)(object)_root == (Object)null || (Object)(object)selected == (Object)null)
			{
				return false;
			}
			if (!((Object)(object)selected == (Object)(object)_root))
			{
				return selected.transform.IsChildOf(_root.transform);
			}
			return true;
		}

		private static void ClearOwnedSelection()
		{
			EventSystem current = EventSystem.current;
			if ((Object)(object)current != (Object)null && IsOwnedControl(current.currentSelectedGameObject))
			{
				current.SetSelectedGameObject((GameObject)null);
			}
		}

		private static void ClearSelectionWithin(Transform parent)
		{
			EventSystem current = EventSystem.current;
			GameObject val = ((current != null) ? current.currentSelectedGameObject : null);
			if ((Object)(object)current != (Object)null && (Object)(object)val != (Object)null && ((Object)(object)val.transform == (Object)(object)parent || val.transform.IsChildOf(parent)))
			{
				current.SetSelectedGameObject((GameObject)null);
			}
		}

		public static void Build(Transform parent, RectTransform overlayRoot, bool preserveInteractionState = false)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00b3: Unknown result type (might be due to invalid IL or missing references)
			DestroyView(preserveInteractionState);
			_overlayRoot = overlayRoot;
			_snapshot = ClanRpc.CurrentSnapshot;
			_directory = ClanRpc.CurrentDirectory;
			_root = CreateWoodPanelObject("ClanPanel", parent, 790f, 520f, draggable: true);
			_rootRect = _root.GetComponent<RectTransform>();
			_rootRect.anchorMin = new Vector2(0.5f, 0.5f);
			_rootRect.anchorMax = new Vector2(0.5f, 0.5f);
			_rootRect.pivot = new Vector2(0.5f, 0.5f);
			_rootRect.sizeDelta = new Vector2(790f, 520f);
			_rootRect.anchoredPosition = Vector2.zero;
			((Graphic)_root.GetComponent<Image>()).raycastTarget = true;
			_root.SetActive(false);
		}

		public static void Tick()
		{
			RefreshMembersNotificationPulse();
			if (IsOpen && !_editorOpen)
			{
				if (_clanRowsDirty)
				{
					_clanRowsDirty = false;
					PopulateClanRows();
				}
				if (_peopleRowsDirty)
				{
					_peopleRowsDirty = false;
					PopulatePeopleRows();
				}
			}
			if (IsOpen && !float.IsPositiveInfinity(_directoryRefreshAt) && !(Time.unscaledTime < _directoryRefreshAt) && !ClanRpc.IsDirectoryRequestPending)
			{
				_directoryRefreshAt = ((ClanRpc.RequestDirectory() > 0) ? float.PositiveInfinity : (Time.unscaledTime + 2.1f));
			}
		}

		public static void DestroyView(bool preserveInteractionState = false)
		{
			ClanUiFeedback.HideTooltip();
			ClearOwnedSelection();
			GameObject root = _root;
			bool num = (Object)(object)root != (Object)null && root.activeSelf;
			_root = null;
			_rootRect = null;
			_overlayRoot = null;
			_profileActionButton = null;
			_membersTabButton = null;
			_membersTabButtonLabel = null;
			_playersTabButton = null;
			_clanSearchInput = null;
			_playerSearchInput = null;
			_clanScroll = null;
			_clanScrollContent = null;
			_peopleScroll = null;
			_peopleScrollContent = null;
			_editorErrorBanner = null;
			_editorErrorLabel = null;
			_positionValid = false;
			if (!preserveInteractionState)
			{
				_editorOpen = false;
				ClearEditorSubmission();
				ClearEditorError();
				_directoryRefreshAt = float.PositiveInfinity;
				ClearConfirmation();
			}
			_directoryPendingAtLastBuild = false;
			_resetClanScrollOnNextPopulate = false;
			_clanRowsDirty = false;
			_peopleRowsDirty = false;
			if ((Object)(object)root != (Object)null)
			{
				root.SetActive(false);
				Object.Destroy((Object)(object)root);
			}
			if (num)
			{
				ClanPanelController.OpenStateChanged?.Invoke(obj: false);
			}
		}

		public static void Toggle()
		{
			if (!((Object)(object)_root == (Object)null))
			{
				if (_root.activeSelf)
				{
					Close();
					return;
				}
				_root.SetActive(true);
				_root.transform.SetAsLastSibling();
				RebuildView();
				PositionPanel();
				ClanPanelController.OpenStateChanged?.Invoke(obj: true);
			}
		}

		public static void Close()
		{
			if (!((Object)(object)_root == (Object)null))
			{
				bool activeSelf = _root.activeSelf;
				ClanUiFeedback.HideTooltip();
				ClearOwnedSelection();
				_editorOpen = false;
				ClearEditorSubmission();
				ClearConfirmation();
				_root.SetActive(false);
				if (activeSelf)
				{
					ClanPanelController.OpenStateChanged?.Invoke(obj: false);
				}
			}
		}

		public static bool HandleCancelInput()
		{
			if (!IsOpen)
			{
				return false;
			}
			ClanUiFeedback.HideTooltip();
			ClearOwnedSelection();
			if (_editorOpen)
			{
				CloseEditor();
				return true;
			}
			if (_confirmAction != ConfirmAction.None)
			{
				ClearConfirmation();
				RebuildView();
				return true;
			}
			Close();
			return true;
		}

		public static bool ContainsPointer(Vector2 pointerPosition)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_rootRect != (Object)null && ((Component)_rootRect).gameObject.activeInHierarchy)
			{
				return RectTransformUtility.RectangleContainsScreenPoint(_rootRect, pointerPosition, ClanUiFactory.GetCanvasCamera((Component?)(object)_rootRect));
			}
			return false;
		}

		public static void RefreshPosition(RectTransform overlayRoot)
		{
			_overlayRoot = overlayRoot;
			if (IsOpen)
			{
				PositionPanel();
			}
		}

		public static void RefreshSnapshot(ClanClientSnapshot snapshot)
		{
			ClanClientSnapshot clanClientSnapshot = snapshot ?? new ClanClientSnapshot();
			string x = _snapshot.Invite?.InviteId ?? "";
			string y = clanClientSnapshot.Invite?.InviteId ?? "";
			bool flag = clanClientSnapshot.Invite != null && !StringComparer.Ordinal.Equals(x, y);
			string clanId = _snapshot.ClanId;
			bool flag2 = !StringComparer.Ordinal.Equals(clanId, clanClientSnapshot.ClanId);
			bool flag3 = !StringComparer.Ordinal.Equals(_snapshot.PrimaryClanId, clanClientSnapshot.PrimaryClanId) || !StringComparer.Ordinal.Equals(_snapshot.GuestClanId, clanClientSnapshot.GuestClanId) || !StringComparer.Ordinal.Equals(x, y) || !StringComparer.Ordinal.Equals(_snapshot.OwnApplicationClanId, clanClientSnapshot.OwnApplicationClanId);
			bool num = _snapshot != clanClientSnapshot;
			bool flag4 = !HasSameSnapshotPresentation(_snapshot, clanClientSnapshot);
			bool flag5 = _snapshot.CanModerate != clanClientSnapshot.CanModerate;
			bool editorOpen = _editorOpen;
			bool flag6 = num && _editorSubmissionPending && _editorSubmissionRequestId > 0 && clanClientSnapshot.ResponseRequestId == _editorSubmissionRequestId;
			bool flag7 = flag6 && SubmittedProfileMatches(clanClientSnapshot);
			_snapshot = clanClientSnapshot;
			if (flag)
			{
				_clanScrollPosition = 1f;
				_resetClanScrollOnNextPopulate = true;
			}
			if (flag5 || flag2 || flag3)
			{
				ClanRpc.InvalidateDirectory();
				_directory = ClanRpc.CurrentDirectory;
				ScheduleDirectoryRefresh();
			}
			if (flag4)
			{
				ClearConfirmation();
			}
			if (num)
			{
				if (_editorOpen && !_editorCreating && (!_snapshot.HasClan || !_snapshot.IsLeader))
				{
					_editorOpen = false;
					ClearEditorSubmission();
					ClearEditorError();
				}
				else if (flag7)
				{
					_editorOpen = false;
					ClearEditorSubmission();
					ClearEditorError();
				}
				else if (flag6)
				{
					ClearEditorSubmission();
					ShowEditorError(string.IsNullOrWhiteSpace(_snapshot.Status) ? ClanLocalization.Text("panel_profile_save_failed") : ClanLocalization.ResolveStatus(_snapshot.Status));
					if (IsOpen)
					{
						RebuildView();
					}
				}
			}
			bool flag8 = editorOpen && !_editorOpen;
			if (IsOpen && flag8 && !_editorOpen)
			{
				RebuildView();
			}
			else if (IsOpen && flag4 && !_editorOpen)
			{
				RefreshHeaderState();
				_clanRowsDirty = true;
				_peopleRowsDirty = true;
			}
		}

		public static void RefreshDirectory(ClanDirectorySnapshot directory)
		{
			ClanDirectorySnapshot clanDirectorySnapshot = directory ?? new ClanDirectorySnapshot();
			if (clanDirectorySnapshot.RequestId > 0)
			{
				_directoryRefreshAt = float.PositiveInfinity;
			}
			bool flag = !HasSameDirectoryPresentation(_directory, clanDirectorySnapshot);
			_directory = clanDirectorySnapshot;
			bool flag2 = IsOpen && _directoryPendingAtLastBuild != ClanRpc.IsDirectoryRequestPending;
			if (IsOpen && (flag || flag2) && !_editorOpen)
			{
				_clanRowsDirty = true;
				if (_tab == PanelTab.Players)
				{
					_peopleRowsDirty = true;
				}
			}
		}

		private static bool HasSameSnapshotPresentation(ClanClientSnapshot left, ClanClientSnapshot right)
		{
			if (StringComparer.Ordinal.Equals(left.ClanId, right.ClanId) && StringComparer.Ordinal.Equals(left.PrimaryClanId, right.PrimaryClanId) && StringComparer.Ordinal.Equals(left.PrimaryClanName, right.PrimaryClanName) && left.PrimaryRole == right.PrimaryRole && StringComparer.Ordinal.Equals(left.GuestClanId, right.GuestClanId) && StringComparer.Ordinal.Equals(left.GuestClanName, right.GuestClanName) && StringComparer.Ordinal.Equals(left.ClanName, right.ClanName) && StringComparer.Ordinal.Equals(left.ClanDescription, right.ClanDescription) && StringComparer.Ordinal.Equals(left.ClanEmblemKey, right.ClanEmblemKey) && left.SelfRole == right.SelfRole && HaveSameItems(left.Roster, right.Roster, HasSameRosterPlayer) && HaveSameItems(left.Applications, right.Applications, HasSameApplication) && HasSameInvite(left.Invite, right.Invite) && StringComparer.Ordinal.Equals(left.OwnApplicationClanId, right.OwnApplicationClanId))
			{
				return StringComparer.Ordinal.Equals(left.OwnApplicationClanName, right.OwnApplicationClanName);
			}
			return false;
		}

		private static bool HasSameDirectoryPresentation(ClanDirectorySnapshot left, ClanDirectorySnapshot right)
		{
			if (left.IsTruncated == right.IsTruncated && HaveSameItems(left.PublicClans, right.PublicClans, HasSamePublicClan))
			{
				return HaveSameItems(left.Players, right.Players, HasSameDirectoryPlayer);
			}
			return false;
		}

		private static bool HasSameRosterPlayer(ClanPlayerSummary left, ClanPlayerSummary right)
		{
			if (StringComparer.Ordinal.Equals(left.Id, right.Id) && StringComparer.Ordinal.Equals(left.Name, right.Name) && left.Role == right.Role && left.IsSelf == right.IsSelf)
			{
				return left.IsOnline == right.IsOnline;
			}
			return false;
		}

		private static bool HasSameApplication(ClanApplicationSummary left, ClanApplicationSummary right)
		{
			if (StringComparer.Ordinal.Equals(left.PlayerId, right.PlayerId))
			{
				return StringComparer.Ordinal.Equals(left.PlayerName, right.PlayerName);
			}
			return false;
		}

		private static bool HasSameInvite(ClanInviteSummary? left, ClanInviteSummary? right)
		{
			if (left == right)
			{
				return true;
			}
			if (left != null && right != null && StringComparer.Ordinal.Equals(left.InviteId, right.InviteId) && StringComparer.Ordinal.Equals(left.ClanId, right.ClanId) && StringComparer.Ordinal.Equals(left.ClanName, right.ClanName))
			{
				return StringComparer.Ordinal.Equals(left.FromName, right.FromName);
			}
			return false;
		}

		private static bool HasSamePublicClan(ClanPublicSummary left, ClanPublicSummary right)
		{
			if (StringComparer.Ordinal.Equals(left.ClanId, right.ClanId) && StringComparer.Ordinal.Equals(left.Name, right.Name) && StringComparer.Ordinal.Equals(left.Description, right.Description) && StringComparer.Ordinal.Equals(left.EmblemKey, right.EmblemKey))
			{
				return StringComparer.Ordinal.Equals(left.LeaderName, right.LeaderName);
			}
			return false;
		}

		private static bool HasSameDirectoryPlayer(ClanDirectoryPlayerSummary left, ClanDirectoryPlayerSummary right)
		{
			if (StringComparer.Ordinal.Equals(left.PlayerId, right.PlayerId) && StringComparer.Ordinal.Equals(left.PlayerName, right.PlayerName) && left.State == right.State && StringComparer.Ordinal.Equals(left.ClanName, right.ClanName) && left.IsOnline == right.IsOnline && left.IsSelf == right.IsSelf && left.CanInvite == right.CanInvite && left.CanResolveApplication == right.CanResolveApplication)
			{
				return left.LastSeenUtcTicks == right.LastSeenUtcTicks;
			}
			return false;
		}

		private static bool HaveSameItems<T>(IReadOnlyList<T> left, IReadOnlyList<T> right, Func<T, T, bool> equals)
		{
			if (left.Count != right.Count)
			{
				return false;
			}
			for (int i = 0; i < left.Count; i++)
			{
				if (!equals(left[i], right[i]))
				{
					return false;
				}
			}
			return true;
		}

		public static void OnEmblemsChanged()
		{
			if (IsOpen)
			{
				if (_editorOpen)
				{
					RebuildView();
				}
				else
				{
					_clanRowsDirty = true;
				}
			}
		}

		private static void RebuildView()
		{
			if (!((Object)(object)_root == (Object)null))
			{
				ClanUiFeedback.HideTooltip();
				ClearOwnedSelection();
				ClanUiFactory.ClearChildren(_root.transform);
				_profileActionButton = null;
				_membersTabButton = null;
				_membersTabButtonLabel = null;
				_playersTabButton = null;
				_clanSearchInput = null;
				_playerSearchInput = null;
				_clanScroll = null;
				_clanScrollContent = null;
				_peopleScroll = null;
				_peopleScrollContent = null;
				_clanRowsDirty = false;
				_peopleRowsDirty = false;
				_editorErrorBanner = null;
				_editorErrorLabel = null;
				_directoryPendingAtLastBuild = ClanRpc.IsDirectoryRequestPending;
				BuildHeader(_root.transform);
				BuildOverview(_root.transform);
				BuildPeoplePane(_root.transform);
				if (_editorOpen)
				{
					BuildEditor(_root.transform);
				}
			}
		}

		private static void BuildHeader(Transform parent)
		{
			//IL_0039: 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_0178: 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_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateRect("Header", parent, 8f, 464f, 774f, 48f, typeof(Image));
			((Graphic)val.GetComponent<Image>()).color = SectionColor;
			CreateLabel(val.transform, ClanLocalization.Text("panel_title"), 10f, 7f, 48f, 34f, 19, (TextAnchor)3, ClanUiFactory.GetClanColor()).fontStyle = (FontStyle)1;
			bool flag = !_snapshot.HasAnyClan;
			bool isLeader = _snapshot.IsLeader;
			_profileActionButton = CreateIconButton(val.transform, ClanActionIcon.Edit, flag ? ClanLocalization.Text("panel_tooltip_create_profile") : (isLeader ? ClanLocalization.Text("panel_tooltip_edit_profile") : ((_snapshot.HasGuestClan && _snapshot.PrimaryRole == ClanRole.Leader) ? ClanLocalization.Text("panel_tooltip_leave_guest_to_edit") : ClanLocalization.Text("panel_tooltip_leader_only_edit"))), flag ? new Action(OpenCreateEditor) : new Action(OpenEditEditor), 90f, 7f, 40f, 34f);
			((Object)_profileActionButton).name = (flag ? "CreateClanProfile" : "EditClanProfile");
			if (!flag && !isLeader)
			{
				((Selectable)_profileActionButton).interactable = false;
				SetButtonContentColor(_profileActionButton, DisabledButtonLabelColor);
			}
			_clanSearchInput = CreateInputField(val.transform, "ClanSearch", _clanSearchQuery, ClanLocalization.Text("panel_search_clans"), 136f, 7f, 140f, 34f, 64, 11);
			((UnityEvent<string>)(object)_clanSearchInput.onValueChanged).AddListener((UnityAction<string>)OnClanSearchChanged);
			ZNet instance = ZNet.instance;
			if (instance != null && instance.IsServer())
			{
				((Object)CreateIconButton(val.transform, ClanActionIcon.Folder, ClanLocalization.Text("panel_tooltip_open_media_folder"), OpenClanMediaDirectory, 282f, 7f, 40f, 34f)).name = "OpenClanMediaDirectory";
			}
			bool flag2 = _tab == PanelTab.Members;
			_membersTabButton = CreateButton(val.transform, ClanLocalization.Text("panel_tab_members"), delegate
			{
				SelectTab(PanelTab.Members);
			}, 355f, 7f, 94f, 34f, flag2 ? ActiveButtonColor : InactiveToggleButtonColor, 13);
			_membersTabButtonLabel = ((Component)_membersTabButton).GetComponentInChildren<Text>(true);
			RefreshMembersNotificationPulse();
			bool flag3 = _tab == PanelTab.Players;
			_playersTabButton = CreateButton(val.transform, ClanLocalization.Text("panel_tab_players"), delegate
			{
				SelectTab(PanelTab.Players);
			}, 455f, 7f, 94f, 34f, flag3 ? ActiveButtonColor : InactiveToggleButtonColor, 13);
			SetButtonLabelColor(_playersTabButton, flag3 ? Color.white : InactiveButtonLabelColor);
			_playerSearchInput = CreateInputField(val.transform, "PlayerSearch", _playerSearchQuery, ClanLocalization.Text("panel_search_player_clan"), 555f, 7f, 140f, 34f, 64, 11);
			((UnityEvent<string>)(object)_playerSearchInput.onValueChanged).AddListener((UnityAction<string>)OnPlayerSearchChanged);
			CreateButton(val.transform, "×", Close, 724f, 7f, 40f, 34f, ButtonColor, 20);
		}

		private static void OpenClanMediaDirectory()
		{
			if (GUIManager.IsHeadless())
			{
				return;
			}
			ZNet instance = ZNet.instance;
			if (instance == null || !instance.IsServer())
			{
				return;
			}
			string text = "";
			try
			{
				text = Path.GetFullPath(ClanPlugin.MediaDirectory);
				Directory.CreateDirectory(text);
				ClanUiFeedback.HideTooltip();
				string text2 = text;
				char directorySeparatorChar = Path.DirectorySeparatorChar;
				Application.OpenURL(text2 + directorySeparatorChar);
			}
			catch (Exception ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Could not open Clan media directory '" + text + "': " + ex.Message));
			}
		}

		private static void RefreshHeaderState()
		{
			//IL_011a: 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_014e: 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_0167: 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_00b3: 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_00ba: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			Button profileActionButton = _profileActionButton;
			if ((Object)(object)profileActionButton != (Object)null)
			{
				bool flag = !_snapshot.HasAnyClan;
				bool isLeader = _snapshot.IsLeader;
				string tooltip = (flag ? ClanLocalization.Text("panel_tooltip_create_profile") : (isLeader ? ClanLocalization.Text("panel_tooltip_edit_profile") : ((_snapshot.HasGuestClan && _snapshot.PrimaryRole == ClanRole.Leader) ? ClanLocalization.Text("panel_tooltip_leave_guest_to_edit") : ClanLocalization.Text("panel_tooltip_leader_only_edit"))));
				((Object)profileActionButton).name = (flag ? "CreateClanProfile" : "EditClanProfile");
				((UnityEventBase)profileActionButton.onClick).RemoveAllListeners();
				UnityAction val = (flag ? new UnityAction(OpenCreateEditor) : new UnityAction(OpenEditEditor));
				((UnityEvent)profileActionButton.onClick).AddListener(val);
				((Selectable)profileActionButton).interactable = flag || isLeader;
				SetButtonContentColor(profileActionButton, ((Selectable)profileActionButton).interactable ? Color.white : DisabledButtonLabelColor);
				ClanUiFeedback.SetTooltip((Selectable)(object)profileActionButton, tooltip);
			}
			bool flag2 = _tab == PanelTab.Members;
			if ((Object)(object)_membersTabButton != (Object)null)
			{
				SetButtonColor(_membersTabButton, flag2 ? ActiveButtonColor : InactiveToggleButtonColor);
				RefreshMembersNotificationPulse();
			}
			bool flag3 = _tab == PanelTab.Players;
			if ((Object)(object)_playersTabButton != (Object)null)
			{
				SetButtonColor(_playersTabButton, flag3 ? ActiveButtonColor : InactiveToggleButtonColor);
				SetButtonLabelColor(_playersTabButton, flag3 ? Color.white : InactiveButtonLabelColor);
			}
		}

		private static bool HasPendingApplications()
		{
			if (_snapshot.CanModerate)
			{
				return _snapshot.Applications.Count > 0;
			}
			return false;
		}

		private static void RefreshMembersNotificationPulse()
		{
			//IL_003c: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_membersTabButton == (Object)null) && !((Object)(object)_membersTabButtonLabel == (Object)null))
			{
				((Graphic)_membersTabButtonLabel).color = (HasPendingApplications() ? ClanUiFeedback.GetNotificationPulseColor() : ((_tab == PanelTab.Members) ? Color.white : InactiveButtonLabelColor));
			}
		}

		private static void BuildOverview(Transform parent)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateRect("ClanOverview", parent, 8f, 8f, 358f, 456f, typeof(Image));
			((Graphic)obj.GetComponent<Image>()).color = SectionColor;
			_clanScroll = CreateScrollView(obj.transform, "ClanRows", 8f, 4f, 342f, 448f, out _clanScrollContent, _clanScrollPosition, delegate(float value)
			{
				_clanScrollPosition = value;
			}, 4f);
			PopulateClanRows();
		}

		private static void PopulateClanRows()
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			ScrollRect clanScroll = _clanScroll;
			RectTransform clanScrollContent = _clanScrollContent;
			if (!((Object)(object)clanScroll == (Object)null) && !((Object)(object)clanScrollContent == (Object)null))
			{
				ClanUiFeedback.HideTooltip();
				ClearSelectionWithin((Transform)(object)clanScrollContent);
				clanScroll.StopMovement();
				ClanUiFactory.ClearChildren((Transform)(object)clanScrollContent);
				_clanRowsDirty = false;
				_directoryPendingAtLastBuild = ClanRpc.IsDirectoryRequestPending;
				IReadOnlyList<ClanPublicSummary> publicClans = _directory.PublicClans;
				IReadOnlyList<ClanPublicSummary> readOnlyList = publicClans.Where(MatchesClanSearch).ToArray();
				if (readOnlyList.Count == 0)
				{
					string text = ((publicClans.Count > 0 && !string.IsNullOrEmpty(_clanSearchQuery)) ? ClanLocalization.Text("panel_no_clans_match") : ((ClanRpc.IsDirectoryRequestPending || !float.IsPositiveInfinity(_directoryRefreshAt)) ? ClanLocalization.Text("panel_loading_clans") : ClanLocalization.Text("panel_no_clans")));
					CreateTopLabel((Transform)(object)clanScrollContent, text, 8f, 202f, 326f, 44f, 13, (TextAnchor)4, MutedColor);
				}
				for (int i = 0; i < readOnlyList.Count; i++)
				{
					BuildClanRow(clanScrollContent, readOnlyList[i], 4f + (float)i * 80f, 76f, i % 2 == 1);
				}
				float requestedHeight = 4f + (float)readOnlyList.Count * 80f;
				SetScrollContentHeight(clanScroll, clanScrollContent, requestedHeight, 448f);
				if (_resetClanScrollOnNextPopulate)
				{
					_clanScrollPosition = 1f;
					_resetClanScrollOnNextPopulate = false;
				}
				clanScroll.verticalNormalizedPosition = Mathf.Clamp01(_clanScrollPosition);
			}
		}

		private static void BuildClanRow(RectTransform content, ClanPublicSummary clan, float top, float height, bool alternate)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: 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_00f4: 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_0141: 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_01ee: 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_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = ClanUiFactory.CreateObject("ClanRow." + clan.ClanId, (Transform)(object)content, typeof(Image));
			PlaceTop(val.GetComponent<RectTransform>(), 3f, top, 336f, height);
			bool flag = _snapshot.IsConnectedToClan(clan.ClanId);
			bool num = StringComparer.Ordinal.Equals(_snapshot.ClanId, clan.ClanId);
			bool flag2 = num && StringComparer.Ordinal.Equals(_snapshot.GuestClanId, clan.ClanId);
			ClanInviteSummary selectedInvite = ((!flag && _snapshot.Invite != null && StringComparer.Ordinal.Equals(_snapshot.Invite.ClanId, clan.ClanId)) ? _snapshot.Invite : null);
			if (num)
			{
				Color clanColor = ClanUiFactory.GetClanColor();
				((Graphic)val.GetComponent<Image>()).color = new Color(clanColor.r * 0.35f, clanColor.g * 0.35f, clanColor.b * 0.35f, 0.72f);
			}
			else
			{
				((Graphic)val.GetComponent<Image>()).color = (Color)(flag ? new Color(0.18f, 0.14f, 0.1f, 0.72f) : (alternate ? AlternateRowColor : RowColor));
			}
			AddEmblem(val.transform, clan.EmblemKey, 6f, 7f, 62f, 62f, clan.Name);
			Text obj = CreateLabel(val.transform, clan.Name, 76f, 49f, 100f, 22f, 12, (TextAnchor)3, ClanUiFactory.GetClanColor());
			obj.resizeTextForBestFit = true;
			obj.resizeTextMinSize = 8;
			obj.resizeTextMaxSize = 12;
			Text obj2 = CreateLabel(val.transform, ClanLocalization.Format("panel_leader_name", clan.LeaderName), 180f, 49f, 76f, 22f, 9, (TextAnchor)5, MutedColor);
			obj2.resizeTextForBestFit = true;
			obj2.resizeTextMinSize = 7;
			obj2.resizeTextMaxSize = 9;
			CreateLabel(val.transform, string.IsNullOrWhiteSpace(clan.Description) ? "—" : clan.Description, 76f, 5f, flag2 ? 166f : 254f, 42f, 9, (TextAnchor)0, string.IsNullOrWhiteSpace(clan.Description) ? MutedColor : Color.white).verticalOverflow = (VerticalWrapMode)0;
			if (flag2)
			{
				GameObject obj3 = ClanUiFactory.CreateObject("ActiveGuestBadge", val.transform, typeof(Image));
				Place(obj3.GetComponent<RectTransform>(), 246f, 29f, 84f, 16f);
				Image component = obj3.GetComponent<Image>();
				((Graphic)component).color = ActiveGuestBadgeColor;
				((Graphic)component).raycastTarget = false;
				Text obj4 = CreateLabel(obj3.transform, ClanLocalization.Text("panel_active_guest"), 3f, 0f, 78f, 16f, 8, (TextAnchor)4, Color.white);
				obj4.resizeTextForBestFit = true;
				obj4.resizeTextMinSize = 6;
				obj4.resizeTextMaxSize = 8;
			}
			BuildClanRowAction(val.transform, clan, selectedInvite);
		}

		private static void BuildClanRowAction(Transform parent, ClanPublicSummary clan, ClanInviteSummary? selectedInvite)
		{
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: 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 (_snapshot.IsConnectedToClan(clan.ClanId))
			{
				if (!StringComparer.Ordinal.Equals(_snapshot.ClanId, clan.ClanId))
				{
					CreateDisabledClanAction(parent, ClanLocalization.Text("panel_action_inactive"), BuildClanRowTooltip(clan, ClanLocalization.Format("panel_tooltip_inactive_guest", _snapshot.GuestClanName)), 260f, 48f, 70f, 23f);
					return;
				}
				bool flag = _snapshot.IsLeader && _snapshot.Roster.Any((ClanPlayerSummary member) => !member.IsSelf && member.Role != ClanRole.Guest);
				bool flag2 = _snapshot.IsLeader && !flag;
				bool flag3 = !flag && IsConfirming(ConfirmAction.Leave, clan.ClanId);
				if (flag)
				{
					CreateDisabledClanAction(parent, ClanLocalization.Text("panel_action_transfer"), BuildClanRowTooltip(clan, ClanLocalization.Text("panel_tooltip_transfer_before_leaving")), 260f, 48f, 70f, 23f);
					return;
				}
				ClanUiFeedback.SetTooltip((Selectable)(object)CreateButton(parent, flag3 ? ClanLocalization.Text("common_confirm_question") : (flag2 ? ClanLocalization.Text("panel_action_disband") : ClanLocalization.Text("panel_action_leave")), delegate
				{
					ConfirmThen(ConfirmAction.Leave, clan.ClanId, delegate
					{
						SendRequest(new ClanRequest
						{
							Type = ClanRequestType.LeaveClan,
							ClanId = clan.ClanId
						});
					});
				}, 260f, 48f, 70f, 23f, flag3 ? DangerColor : ButtonColor, 9), BuildClanRowTooltip(clan, flag3 ? ClanLocalization.Text("common_click_again_confirm") : (flag2 ? ClanLocalization.Format("panel_tooltip_disband", clan.Name) : ClanLocalization.Format("panel_tooltip_leave", clan.Name))));
			}
			else if (selectedInvite != null)
			{
				ClanInviteSummary invite = selectedInvite;
				((Object)CreateIconButton(parent, ClanActionIcon.Accept, BuildClanRowTooltip(clan, ClanLocalization.Format("panel_tooltip_accept_invite", invite.ClanName, invite.FromName)), delegate
				{
					SendRequest(new ClanRequest
					{
						Type = ClanRequestType.AcceptInvite,
						InviteId = invite.InviteId
					});
				}, 260f, 48f, 33f, 23f, ButtonColor)).name = "AcceptInvite";
				((Object)CreateIconButton(parent, ClanActionIcon.Decline, BuildClanRowTooltip(clan, ClanLocalization.Format("panel_tooltip_decline_invite", invite.ClanName, invite.FromName)), delegate
				{
					SendRequest(new ClanRequest
					{
						Type = ClanRequestType.DeclineInvite,
						InviteId = invite.InviteId
					});
				}, 297f, 48f, 33f, 23f, ButtonColor)).name = "DeclineInvite";
			}
			else if (_snapshot.HasOwnApplication)
			{
				if (StringComparer.Ordinal.Equals(_snapshot.OwnApplicationClanId, clan.ClanId))
				{
					ClanUiFeedback.SetTooltip((Selectable)(object)CreateButton(parent, ClanLocalization.Text("common_cancel"), delegate
					{
						SendRequest(ClanRequest.Simple(ClanRequestType.CancelApplication));
					}, 260f, 48f, 70f, 23f, ButtonColor, 9), BuildClanRowTooltip(clan, ClanLocalization.Format("panel_tooltip_cancel_application", clan.Name)));
				}
				else
				{
					CreateDisabledClanAction(parent, ClanLocalization.Text("panel_state_pending"), BuildClanRowTooltip(clan, ClanLocalization.Format("panel_tooltip_application_pending", _snapshot.OwnApplicationClanName)), 260f, 48f, 70f, 23f);
				}
			}
			else if (_snapshot.HasGuestClan)
			{
				CreateDisabledClanAction(parent, ClanLocalization.Text("panel_state_unavailable"), BuildClanRowTooltip(clan, ClanLocalization.Format("panel_tooltip_guest_slot_used", _snapshot.GuestClanName)), 260f, 48f, 70f, 23f);
			}
			else
			{
				ClanUiFeedback.SetTooltip((Selectable)(object)CreateButton(parent, ClanLocalization.Text("panel_action_apply"), delegate
				{
					ApplyToClan(clan.ClanId);
				}, 260f, 48f, 70f, 23f, ActiveButtonColor, 9), BuildClanRowTooltip(clan, ClanLocalization.Format("panel_tooltip_apply", clan.Name)));
			}
		}

		private static string BuildClanRowTooltip(ClanPublicSummary clan, string action)
		{
			string text = (string.IsNullOrWhiteSpace(clan.Description) ? ClanLocalization.Text("panel_no_description") : clan.Description);
			return ClanLocalization.Format("panel_clan_tooltip_summary", action, clan.Name, clan.LeaderName, text);
		}

		private static void CreateDisabledClanAction(Transform parent, string text, string tooltip, float x, float y, float width, float height)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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)
			Button obj = CreateButton(parent, text, delegate
			{
			}, x, y, width, height, ButtonColor, 8);
			ColorBlock colors = ((Selectable)obj).colors;
			((ColorBlock)(ref colors)).disabledColor = DisabledButtonColor;
			((Selectable)obj).colors = colors;
			((Selectable)obj).interactable = false;
			SetButtonLabelColor(obj, DisabledButtonLabelColor);
			ClanUiFeedback.SetTooltip((Selectable)(object)obj, tooltip);
		}

		private static void BuildPeoplePane(Transform parent)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateRect("PeoplePane", parent, 366f, 8f, 408f, 456f, typeof(Image));
			((Graphic)obj.GetComponent<Image>()).color = SectionColor;
			_peopleScroll = CreateScrollView(obj.transform, "PeopleScroll", -3f, 4f, 411f, 448f, out _peopleScrollContent, _rightScrollPosition, delegate(float value)
			{
				_rightScrollPosition = value;
			}, 6f);
			PopulatePeopleRows();
		}

		private static void PopulatePeopleRows()
		{
			ScrollRect peopleScroll = _peopleScroll;
			RectTransform peopleScrollContent = _peopleScrollContent;
			if (!((Object)(object)peopleScroll == (Object)null) && !((Object)(object)peopleScrollContent == (Object)null))
			{
				ClanUiFeedback.HideTooltip();
				ClearSelectionWithin((Transform)(object)peopleScrollContent);
				peopleScroll.StopMovement();
				ClanUiFactory.ClearChildren((Transform)(object)peopleScrollContent);
				_peopleRowsDirty = false;
				_directoryPendingAtLastBuild = ClanRpc.IsDirectoryRequestPending;
				float requestedHeight = ((_tab == PanelTab.Members) ? BuildMembersTab(peopleScrollContent) : BuildPlayersTab(peopleScrollContent));
				SetScrollContentHeight(peopleScroll, peopleScrollContent, requestedHeight, 448f);
				peopleScroll.verticalNormalizedPosition = Mathf.Clamp01(_rightScrollPosition);
			}
		}

		private static float BuildMembersTab(RectTransform content)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_0517: Unknown result type (might be due to invalid IL or missing references)
			//IL_0510: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05da: Unknown result type (might be due to invalid IL or missing references)
			string effectiveClanId = _snapshot.ClanId;
			float num = 6f;
			if (!_snapshot.HasClan)
			{
				CreateTopLabel((Transform)(object)content, ClanLocalization.Text("panel_join_or_create_for_roster"), 8f, num + 12f, 396f, 44f, 13, (TextAnchor)4, MutedColor);
				return num + 64f;
			}
			IReadOnlyList<ClanApplicationSummary> readOnlyList = (_snapshot.CanModerate ? _snapshot.Applications.Where((ClanApplicationSummary application) => SearchMatches(application.PlayerName, _playerSearchQuery)).OrderBy<ClanApplicationSummary, string>((ClanApplicationSummary application) => application.PlayerName, StringComparer.OrdinalIgnoreCase).ToArray() : Array.Empty<ClanApplicationSummary>());
			IReadOnlyList<ClanPlayerSummary> readOnlyList2 = (from clanPlayerSummary in _snapshot.Roster
				where SearchMatches(clanPlayerSummary.Name, _playerSearchQuery)
				orderby clanPlayerSummary.IsSelf descending, clanPlayerSummary.Role
				select clanPlayerSummary).ThenBy<ClanPlayerSummary, string>((ClanPlayerSummary clanPlayerSummary) => clanPlayerSummary.Name, StringComparer.OrdinalIgnoreCase).ToArray();
			if (!string.IsNullOrEmpty(_playerSearchQuery) && readOnlyList.Count == 0 && readOnlyList2.Count == 0)
			{
				CreateTopLabel((Transform)(object)content, ClanLocalization.Text("panel_no_players_match"), 8f, num + 12f, 396f, 44f, 13, (TextAnchor)4, MutedColor);
				return num + 64f;
			}
			if (readOnlyList.Count > 0)
			{
				foreach (ClanApplicationSummary item in readOnlyList)
				{
					GameObject obj = CreateTopRow(content, num, 36f, alternate: false);
					Text obj2 = CreateLabel(obj.transform, item.PlayerName, 7f, 10f, 140f, 16f, 11, (TextAnchor)3, Color.white);
					obj2.resizeTextForBestFit = true;
					obj2.resizeTextMinSize = 8;
					obj2.resizeTextMaxSize = 11;
					Text obj3 = CreateLabel(obj.transform, ClanLocalization.Text("panel_state_application"), 151f, 10f, 111f, 16f, 9, (TextAnchor)3, MutedColor);
					obj3.resizeTextForBestFit = true;
					obj3.resizeTextMinSize = 8;
					obj3.resizeTextMaxSize = 9;
					BuildApplicationDecisionButtons(obj.transform, effectiveClanId, item.PlayerId, item.PlayerName, new Rect(266f, 4f, 64f, 28f), new Rect(334f, 4f, 68f, 28f));
					num += 40f;
				}
				if (readOnlyList2.Count > 0)
				{
					num += 4f;
				}
			}
			int num2 = 0;
			foreach (ClanPlayerSummary member in readOnlyList2)
			{
				GameObject val = CreateTopRow(content, num, 36f, num2++ % 2 == 1);
				Text obj4 = CreateLabel(val.transform, member.Name, 7f, 10f, 140f, 16f, 11, (TextAnchor)3, member.IsSelf ? AccentColor : Color.white);
				obj4.resizeTextForBestFit = true;
				obj4.resizeTextMinSize = 8;
				obj4.resizeTextMaxSize = 11;
				if (CanAffectMember(_snapshot, member))
				{
					if (_snapshot.IsLeader)
					{
						CreateRoleButton(val.transform, member, ClanRole.Officer, ClanLocalization.Role(ClanRole.Officer), 201f, 48f);
					}
					CreateRoleButton(val.transform, member, ClanRole.Member, ClanLocalization.Role(ClanRole.Member), 253f, 52f);
					CreateRoleButton(val.transform, member, ClanRole.Guest, ClanLocalization.Role(ClanRole.Guest), 309f, 46f);
				}
				else
				{
					CreateLabel(val.transform, ClanLocalization.Role(member.Role), 151f, 7f, 108f, 22f, 10, (TextAnchor)3, MutedColor);
				}
				bool flag = _snapshot.IsLeader && !member.IsSelf;
				if (flag)
				{
					ClanRole role = member.Role;
					bool flag2 = (uint)(role - 1) <= 1u;
					flag = flag2;
				}
				if (flag)
				{
					bool flag3 = IsConfirming(ConfirmAction.TransferLeadership, member.Id);
					ClanUiFeedback.SetTooltip((Selectable)(object)CreateButton(val.transform, flag3 ? ClanLocalization.Text("common_sure_question") : ClanLocalization.Role(ClanRole.Leader), delegate
					{
						ConfirmThen(ConfirmAction.TransferLeadership, member.Id, delegate
						{
							SendRequest(new ClanRequest
							{
								Type = ClanRequestType.TransferLeadership,
								ClanId = effectiveClanId,
								TargetId = member.Id
							});
						});
					}, 151f, 4f, 46f, 28f, flag3 ? DangerColor : ButtonColor, 8), flag3 ? ClanLocalization.Format("panel_tooltip_confirm_transfer_leadership", member.Name) : ClanLocalization.Format("panel_tooltip_transfer_leadership", member.Name));
				}
				if (CanAffectMember(_snapshot, member))
				{
					bool flag4 = IsConfirming(ConfirmAction.Kick, member.Id);
					CreateButton(val.transform, flag4 ? ClanLocalization.Text("common_sure_question") : ClanLocalization.Text("panel_action_kick"), delegate
					{
						ConfirmThen(ConfirmAction.Kick, member.Id, delegate
						{
							SendRequest(new ClanRequest
							{
								Type = ClanRequestType.KickPlayer,
								ClanId = effectiveClanId,
								TargetId = member.Id
							});
						});
					}, 359f, 4f, 43f, 28f, flag4 ? DangerColor : ButtonColor, 9);
				}
				num += 40f;
			}
			return num + 2f;
		}

		private static void CreateRoleButton(Transform parent, ClanPlayerSummary member, ClanRole role, string label, float x, float width)
		{
			//IL_007b: 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_0092: 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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			string effectiveClanId = _snapshot.ClanId;
			if (ClanDataRules.GetRolePower(_snapshot.SelfRole) > ClanDataRules.GetRolePower(role))
			{
				bool flag = member.Role == role;
				Button val = CreateButton(parent, label, delegate
				{
					SendRequest(new ClanRequest
					{
						Type = ClanRequestType.SetRole,
						ClanId = effectiveClanId,
						TargetId = member.Id,
						Role = role
					});
				}, x, 4f, width, 28f, flag ? ActiveButtonColor : InactiveToggleButtonColor, 8);
				SetButtonLabelColor(val, flag ? Color.white : InactiveButtonLabelColor);
				ClanUiFeedback.SetTooltip((Selectable)(object)val, flag ? ClanLocalization.Format("panel_tooltip_role_already_set", member.Name, ClanLocalization.Role(role)) : ClanLocalization.Format("panel_tooltip_set_role", member.Name, ClanLocalization.Role(role)));
				if (flag)
				{
					ColorBlock colors = ((Selectable)val).colors;
					((ColorBlock)(ref colors)).disabledColor = ActiveButtonColor;
					((Selectable)val).colors = colors;
					((Selectable)val).interactable = false;
				}
			}
		}

		private static float BuildPlayersTab(RectTransform content)
		{
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: 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_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			string effectiveClanId = _snapshot.ClanId;
			float num = 6f;
			IReadOnlyList<ClanDirectoryPlayerSummary> players = _directory.Players;
			IReadOnlyList<ClanDirectoryPlayerSummary> readOnlyList = (from clanDirectoryPlayerSummary in players
				where SearchMatches(clanDirectoryPlayerSummary.PlayerName, _playerSearchQuery) || SearchMatches(clanDirectoryPlayerSummary.ClanName, _playerSearchQuery)
				orderby clanDirectoryPlayerSummary.IsSelf descending, clanDirectoryPlayerSummary.CanResolveApplication descending, clanDirectoryPlayerSummary.IsOnline descending, clanDirectoryPlayerSummary.LastSeenUtcTicks descending
				select clanDirectoryPlayerSummary).ThenBy<ClanDirectoryPlayerSummary, string>((ClanDirectoryPlayerSummary clanDirectoryPlayerSummary) => clanDirectoryPlayerSummary.PlayerName, StringComparer.OrdinalIgnoreCase).ToArray();
			if (readOnlyList.Count == 0)
			{
				string text = ((players.Count > 0 && !string.IsNullOrEmpty(_playerSearchQuery)) ? ClanLocalization.Text("panel_no_players_or_clans_match") : (ClanRpc.IsDirectoryRequestPending ? ClanLocalization.Text("panel_loading_recent_players") : ClanLocalization.Text("panel_no_recent_players")));
				CreateTopLabel((Transform)(object)content, text, 8f, num + 12f, 396f, 44f, 13, (TextAnchor)4, MutedColor);
				return num + 64f;
			}
			int num2 = 0;
			foreach (ClanDirectoryPlayerSummary player in readOnlyList)
			{
				GameObject val = CreateTopRow(content, num, 36f, num2++ % 2 == 1);
				Text obj = CreateLabel(val.transform, player.PlayerName, 7f, 10f, 140f, 16f, 11, (TextAnchor)3, player.IsSelf ? AccentColor : Color.white);
				obj.resizeTextForBestFit = true;
				obj.resizeTextMinSize = 8;
				obj.resizeTextMaxSize = 11;
				Text obj2 = CreateLabel(val.transform, DirectoryStateText(player), 151f, 10f, 111f, 16f, 10, (TextAnchor)3, DirectoryStateColor(player.State));
				obj2.resizeTextForBestFit = true;
				obj2.resizeTextMinSize = 8;
				obj2.resizeTextMaxSize = 10;
				Text obj3 = CreateLabel(val.transform, LastSeenText(player), 266f, 7f, 64f, 21f, 10, (TextAnchor)5, player.IsOnline ? ClanUiFactory.GetClanColor() : MutedColor);
				obj3.resizeTextForBestFit = true;
				obj3.resizeTextMinSize = 8;
				obj3.resizeTextMaxSize = 10;
				if (_snapshot.CanModerate && player.CanInvite)
				{
					Button obj4 = CreateButton(val.transform, ClanLocalization.Text("panel_action_invite"), delegate
					{
						SendRequest(new ClanRequest
						{
							Type = ClanRequestType.Invite,
							ClanId = effectiveClanId,
							TargetId = player.PlayerId
						});
					}, 334f, 4f, 68f, 28f, ButtonColor, 9);
					((Object)obj4).name = "InvitePlayer";
					ClanUiFeedback.SetTooltip((Selectable)(object)obj4, ClanLocalization.Format("panel_tooltip_invite_player", player.PlayerName));
				}
				num += 40f;
			}
			return num + 2f;
		}

		private static void BuildApplicationDecisionButtons(Transform parent, string clanId, string playerId, string playerName, Rect acceptBounds, Rect declineBounds)
		{
			//IL_0047: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			Button obj = CreateButton(parent, ClanLocalization.Text("panel_action_accept"), delegate
			{
				SendRequest(new ClanRequest
				{
					Type = ClanRequestType.AcceptApplication,
					ClanId = clanId,
					TargetId = playerId
				});
			}, ((Rect)(ref acceptBounds)).x, ((Rect)(ref acceptBounds)).y, ((Rect)(ref acceptBounds)).width, ((Rect)(ref acceptBounds)).height, ButtonColor, 9);
			((Object)obj).name = "AcceptApplication";
			ClanUiFeedback.SetTooltip((Selectable)(object)obj, ClanLocalization.Format("panel_tooltip_accept_application", playerName));
			bool flag = IsConfirming(ConfirmAction.RejectApplication, playerId);
			Button obj2 = CreateButton(parent, flag ? ClanLocalization.Text("panel_action_decline_question") : ClanLocalization.Text("panel_action_decline"), delegate
			{
				ConfirmThen(ConfirmAction.RejectApplication, playerId, delegate
				{
					SendRequest(new ClanRequest
					{
						Type = ClanRequestType.RejectApplication,
						ClanId = clanId,
						TargetId = playerId
					});
				});
			}, ((Rect)(ref declineBounds)).x, ((Rect)(ref declineBounds)).y, ((Rect)(ref declineBounds)).width, ((Rect)(ref declineBounds)).height, flag ? DangerColor : ButtonColor, 9);
			((Object)obj2).name = "DeclineApplication";
			ClanUiFeedback.SetTooltip((Selectable)(object)obj2, flag ? ClanLocalization.Format("panel_tooltip_confirm_decline_application", playerName) : ClanLocalization.Format("panel_tooltip_decline_application", playerName));
		}

		private static void BuildEditor(Transform parent)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: 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_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			Selectable[] componentsInChildren = _root.GetComponentsInChildren<Selectable>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].interactable = false;
			}
			GameObject val = CreateRect("ProfileEditorBlocker", parent, 0f, 0f, 790f, 520f, typeof(Image));
			((Graphic)val.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.62f);
			((Graphic)val.GetComponent<Image>()).raycastTarget = true;
			GameObject val2 = CreateWoodPanelObject("ProfileEditor", val.transform, 650f, 470f, draggable: false);
			Place(val2.GetComponent<RectTransform>(), 70f, 25f, 650f, 470f);
			((Graphic)val2.GetComponent<Image>()).raycastTarget = true;
			CreateLabel(val2.transform, _editorCreating ? ClanLocalization.Text("panel_editor_make_clan") : ClanLocalization.Format("panel_editor_edit_clan", _snapshot.ClanName), 14f, 426f, 420f, 32f, 18, (TextAnchor)3, AccentColor);
			Button val3 = CreateButton(val2.transform, _editorSubmissionPending ? ClanLocalization.Text("panel_editor_sending") : (_editorCreating ? ClanLocalization.Text("panel_editor_create_clan") : ClanLocalization.Text("panel_editor_save_profile")), SubmitEditor, 448f, 426f, 138f, 32f, ActiveButtonColor, 12);
			((Selectable)val3).interactable = !_editorSubmissionPending;
			if (_editorSubmissionPending)
			{
				SetButtonLabelColor(val3, DisabledButtonLabelColor);
			}
			CreateButton(val2.transform, "×", CloseEditor, 594f, 426f, 40f, 32f, ButtonColor, 19);
			CreateLabel(val2.transform, ClanLocalization.Text("panel_editor_clan_name"), 14f, 394f, 180f, 24f, 12, (TextAnchor)3, MutedColor);
			InputField obj = CreateInputField(val2.transform, "ClanName", _draftName, ClanLocalization.Text("panel_editor_name_placeholder"), 14f, 358f, 620f, 34f, 80);
			((Selectable)obj).interactable = !_editorSubmissionPending;
			((UnityEvent<string>)(object)obj.onValueChanged).AddListener((UnityAction<string>)delegate(string value)
			{
				_draftName = value;
				ClearEditorError();
			});
			CreateLabel(val2.transform, ClanLocalization.Text("panel_editor_description"), 14f, 330f, 180f, 24f, 12, (TextAnchor)3, MutedColor);
			InputField obj2 = CreateInputField(val2.transform, "ClanDescription", _draftDescription, ClanLocalization.Text("panel_editor_description_placeholder"), 14f, 254f, 620f, 70f, 160);
			((Selectable)obj2).interactable = !_editorSubmissionPending;
			((UnityEvent<string>)(object)obj2.onValueChanged).AddListener((UnityAction<string>)delegate(string value)
			{
				_draftDescription = value;
				ClearEditorError();
			});
			CreateLabel(val2.transform, ClanLocalization.Text("panel_editor_emblem"), 14f, 226f, 260f, 24f, 12, (TextAnchor)3, MutedColor);
			BuildEditorEmblemPicker(val2.transform);
			BuildEditorErrorBanner(val2.transform);
		}

		private static void BuildEditorEmblemPicker(Transform parent)
		{
			//IL_00bd: 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_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			RectTransform content;
			ScrollRect val = CreateScrollView(parent, "EmblemPicker", 14f, 14f, 620f, 206f, out content, _emblemScrollPosition, delegate(float value)
			{
				_emblemScrollPosition = value;
			});
			((Behaviour)val).enabled = !_editorSubmissionPending;
			IReadOnlyList<ClanEmoji.ClanEmblemPickerItem> emblemPickerItems = ClanEmoji.GetEmblemPickerItems();
			int num = emblemPickerItems.Count + 1;
			bool flag = string.IsNullOrWhiteSpace(_draftEmblemKey);
			Button obj = CreateTopButton((Transform)(object)content, ClanLocalization.Text("common_none"), delegate
			{
				SelectDraftEmblem("");
			}, 5f, 5f, 58f, 58f, flag ? ActivePickerButtonColor : PickerButtonColor, 10);
			RemoveButtonFrame(obj);
			SetPickerButtonState(obj, flag, !_editorSubmissionPending);
			ClanUiFeedback.SetTooltip((Selectable)(object)obj, ClanLocalization.Text("panel_tooltip_no_emblem"));
			for (int num2 = 0; num2 < emblemPickerItems.Count; num2++)
			{
				ClanEmoji.ClanEmblemPickerItem emblem = emblemPickerItems[num2];
				int num3 = num2 + 1;
				int num4 = num3 % 9;
				int num5 = num3 / 9;
				bool flag2 = StringComparer.Ordinal.Equals(_draftEmblemKey, emblem.Name);
				Button obj2 = CreateTopButton((Transform)(object)content, "", delegate
				{
					SelectDraftEmblem(emblem.Name);
				}, 5f + (float)num4 * 64f, 5f + (float)num5 * 64f, 58f, 58f, flag2 ? ActivePickerButtonColor : PickerButtonColor, 10);
				RemoveButtonFrame(obj2);
				AddSprite(((Component)obj2).transform, emblem.Sprite, 7f, 7f, 44f, 44f);
				SetPickerButtonState(obj2, flag2, !_editorSubmissionPending);
			}
			int num6 = Math.Max(1, (num + 9 - 1) / 9);
			SetScrollContentHeight(val, content, 10f + (float)num6 * 64f, 206f);
			val.verticalNormalizedPosition = Mathf.Clamp01(_emblemScrollPosition);
		}

		private static void BuildEditorErrorBanner(Transform parent)
		{
			//IL_0056: 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)
			_editorErrorBanner = CreateRect("EditorError", parent, 14f, 14f, 620f, 36f, typeof(Image));
			Image component = _editorErrorBanner.GetComponent<Image>();
			((Graphic)component).color = new Color(0.38f, 0.1f, 0.08f, 0.96f);
			((Graphic)component).raycastTarget = false;
			_editorErrorLabel = CreateLabel(_editorErrorBanner.transform, _editorError, 10f, 2f, 600f, 32f, 11, (TextAnchor)3, Color.white);
			_editorErrorLabel.horizontalOverflow = (HorizontalWrapMode)0;
			_editorErrorLabel.verticalOverflow = (VerticalWrapMode)0;
			_editorErrorBanner.SetActive(!string.IsNullOrWhiteSpace(_editorError));
		}

		private static void OpenCreateEditor()
		{
			ClearConfirmation();
			_editorOpen = true;
			_editorCreating = true;
			ClearEditorSubmission();
			ClearEditorError();
			_draftName = "";
			_draftDescription = "";
			_draftEmblemKey = "";
			RebuildView();
		}

		private static void OpenEditEditor()
		{
			if (!_snapshot.IsLeader)
			{
				ClanRpc.NotifyStatus(ClanLocalization.Text("panel_error_leader_only_edit"));
				return;
			}
			ClearConfirmation();
			_editorOpen = true;
			_editorCreating = false;
			ClearEditorSubmission();
			ClearEditorError();
			_draftName = _snapshot.ClanName;
			_draftDescription = _snapshot.ClanDescription;
			_draftEmblemKey = _snapshot.ClanEmblemKey;
			RebuildView();
		}

		private static void CloseEditor()
		{
			_editorOpen = false;
			ClearEditorSubmission();
			ClearEditorError();
			RebuildView();
		}

		private static void SubmitEditor()
		{
			if (_editorSubmissionPending)
			{
				return;
			}
			ClearEditorError();
			try
			{
				string draftName = ClanDataRules.RequireClanName(_draftName);
				string draftDescription = ClanDataRules.RequireClanDescription((_draftDescription ?? "").Replace('\r', ' ').Replace('\n', ' '));
				string text = ClanDataRules.RequireClanEmblemKey(_draftEmblemKey);
				if (!ClanEmoji.IsAvailableEmblemKey(text))
				{
					ShowEditorError(ClanLocalization.Text("panel_error_select_available_emblem"));
					return;
				}
				_draftName = draftName;
				_draftDescription = draftDescription;
				_draftEmblemKey = text;
				ClanRequest clanRequest;
				if (_editorCreating)
				{
					if (_snapshot.HasAnyClan)
					{
						ShowEditorError(ClanLocalization.Text("panel_error_leave_before_create"));
						return;
					}
					clanRequest = new ClanRequest
					{
						Type = ClanRequestType.CreateClan,
						ClanName = _draftName,
						Description = _draftDescription,
						EmblemKey = _draftEmblemKey
					};
				}
				else
				{
					if (!_snapshot.IsLeader)
					{
						ShowEditorError(ClanLocalization.Text("panel_error_leader_only_edit"));
						return;
					}
					if (SubmittedProfileMatches(_snapshot))
					{
						_editorOpen = false;
						ClearEditorSubmission();
						ClearEditorError();
						RebuildView();
						return;
					}
					clanRequest = new ClanRequest
					{
						Type = ClanRequestType.UpdateClanProfile,
						ClanId = _snapshot.ClanId,
						ClanName = _draftName,
						Description = _draftDescription,
						EmblemKey = _draftEmblemKey
					};
				}
				clanRequest.RequestId = ClanRpc.NextRequestId();
				_editorSubmissionRequestId = clanRequest.RequestId;
				_editorSubmissionPending = true;
				RebuildView();
				if (!ClanRpc.Send(clanRequest))
				{
					ClearEditorSubmission();
					ShowEditorError(ClanLocalization.Text("panel_error_server_not_connected"));
					RebuildView();
				}
				else
				{
					ScheduleDirectoryRefresh();
				}
			}
			catch (InvalidDataException exception)
			{
				ClearEditorSubmission();
				ShowEditorError(LocalizeEditorValidationError(exception));
			}
		}

		private static void ClearEditorSubmission()
		{
			_editorSubmissionPending = false;
			_editorSubmissionRequestId = 0L;
		}

		private static string LocalizeEditorValidationError(InvalidDataException exception)
		{
			if (!ClanDataRules.TryGetValidationError(exception, out var field, out var error))
			{
				return ClanLocalization.Text("panel_error_invalid_profile");
			}
			switch (field)
			{
			case ClanValidationField.ClanName:
				switch (error)
				{
				case ClanValidationError.Required:
					return ClanLocalization.Text("panel_error_name_required");
				case ClanValidationError.InvalidUnicode:
					return ClanLocalization.Text("panel_error_name_invalid_unicode");
				case ClanValidationError.InvalidCharacters:
					return ClanLocalization.Text("panel_error_name_invalid_characters");
				case ClanValidationError.TooLong:
					return ClanLocalization.Format("panel_error_name_too_long", 40);
				case ClanValidationError.TrailingSeparator:
					return ClanLocalization.Text("panel_error_name_trailing_separator");
				case ClanValidationError.MissingLetterOrNumber:
					return ClanLocalization.Text("panel_error_name_letter_number");
				}
				break;
			case ClanValidationField.ClanDescription:
				switch (error)
				{
				case ClanValidationError.TooLong:
					return ClanLocalization.Format("panel_error_description_too_long", 160);
				case ClanValidationError.RichText:
					return ClanLocalization.Text("panel_error_description_rich_text");
				case ClanValidationError.ControlCharacters:
					return ClanLocalization.Text("panel_error_description_control_characters");
				}
				break;
			case ClanValidationField.ClanEmblemKey:
				switch (error)
				{
				case ClanValidationError.TooLong:
					return ClanLocalization.Format("panel_error_emblem_too_long", 32);
				case ClanValidationError.RichText:
					return ClanLocalization.Text("panel_error_emblem_rich_text");
				case ClanValidationError.ControlCharacters:
					return ClanLocalization.Text("panel_error_emblem_control_characters");
				case ClanValidationError.InvalidStartOrEnd:
					return ClanLocalization.Text("panel_error_emblem_start_end");
				case ClanValidationError.InvalidCharacters:
					return ClanLocalization.Text("panel_error_emblem_invalid_characters");
				}
				break;
			}
			return ClanLocalization.Text("panel_error_invalid_profile");
		}

		private static void ShowEditorError(string message)
		{
			_editorError = ClanUiFactory.CleanSingleLine(message);
			if ((Object)(object)_editorErrorLabel != (Object)null)
			{
				_editorErrorLabel.text = _editorError;
			}
			if ((Object)(object)_editorErrorBanner != (Object)null)
			{
				_editorErrorBanner.SetActive(_editorError.Length > 0);
			}
		}

		private static void ClearEditorError()
		{
			_editorError = "";
			if ((Object)(object)_editorErrorLabel != (Object)null)
			{
				_editorErrorLabel.text = "";
			}
			if ((Object)(object)_editorErrorBanner != (Object)null)
			{
				_editorErrorBanner.SetActive(false);
			}
		}

		private static bool SubmittedProfileMatches(ClanClientSnapshot snapshot)
		{
			if (snapshot.HasClan && StringComparer.Ordinal.Equals(snapshot.ClanName, _draftName) && StringComparer.Ordinal.Equals(snapshot.ClanDescription, _draftDescription))
			{
				return StringComparer.Ordinal.Equals(snapshot.ClanEmblemKey, _draftEmblemKey);
			}
			return false;
		}

		private static void SelectDraftEmblem(string emblemKey)
		{
			if (!_editorSubmissionPending)
			{
				_draftEmblemKey = emblemKey ?? "";
				ClearEditorError();
				RebuildView();
			}
		}

		private static void SelectTab(PanelTab tab)
		{
			if (_tab != tab)
			{
				_tab = tab;
				_rightScrollPosition = 1f;
				ClearConfirmation();
				RefreshHeaderState();
				PopulatePeopleRows();
				if (_tab == PanelTab.Players && _directory.RequestId <= 0)
				{
					ClanRpc.RequestDirectory();
				}
			}
		}

		private static void OnClanSearchChanged(string value)
		{
			string text = NormalizeSearchQuery(value);
			if (!StringComparer.Ordinal.Equals(_clanSearchQuery, text))
			{
				_clanSearchQuery = text;
				_clanScrollPosition = 1f;
				ClearConfirmation();
				_clanRowsDirty = true;
			}
		}

		private static void OnPlayerSearchChanged(string value)
		{
			string text = NormalizeSearchQuery(value);
			if (!StringComparer.Ordinal.Equals(_playerSearchQuery, text))
			{
				_playerSearchQuery = text;
				_rightScrollPosition = 1f;
				ClearConfirmation();
				_peopleRowsDirty = true;
			}
		}

		private static string NormalizeSearchQuery(string value)
		{
			return (value ?? "").Trim();
		}

		private static bool MatchesClanSearch(ClanPublicSummary clan)
		{
			if (!SearchMatches(clan.Name, _clanSearchQuery) && !SearchMatches(clan.LeaderName, _clanSearchQuery))
			{
				return SearchMatches(clan.Description, _clanSearchQuery);
			}
			return true;
		}

		private static bool SearchMatches(string? value, string query)
		{
			if (!string.IsNullOrEmpty(query))
			{
				return (value ?? "").IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		internal static void ResetSearchState()
		{
			bool num = !string.IsNullOrEmpty(_clanSearchQuery) || !string.IsNullOrEmpty(_playerSearchQuery);
			_clanSearchQuery = "";
			_playerSearchQuery = "";
			_clanScrollPosition = 1f;
			_rightScrollPosition = 1f;
			if ((Object)(object)_clanSearchInput != (Object)null)
			{
				_clanSearchInput.SetTextWithoutNotify("");
			}
			if ((Object)(object)_playerSearchInput != (Object)null)
			{
				_playerSearchInput.SetTextWithoutNotify("");
			}
			if (num)
			{
				_clanRowsDirty = true;
				_peopleRowsDirty = true;
			}
		}

		private static void ApplyToClan(string clanId)
		{
			SendRequest(new ClanRequest
			{
				Type = ClanRequestType.Apply,
				ClanId = clanId
			});
		}

		private static void SendRequest(ClanRequest request)
		{
			ClearConfirmation();
			if (ClanRpc.Send(request))
			{
				ScheduleDirectoryRefresh();
			}
		}

		private static void ScheduleDirectoryRefresh()
		{
			_directoryRefreshAt = Mathf.Min(_directoryRefreshAt, Time.unscaledTime + 2.1f);
		}

		private static void ConfirmThen(ConfirmAction action, string target, Action confirmed)
		{
			if (IsConfirming(action, target))
			{
				ClearConfirmation();
				if (IsOpen)
				{
					RebuildView();
				}
				confirmed();
			}
			else
			{
				_confirmAction = action;
				_confirmTarget = target ?? "";
				RebuildView();
			}
		}

		private static bool IsConfirming(ConfirmAction action, string target)
		{
			if (_confirmAction == action)
			{
				return StringComparer.Ordinal.Equals(_confirmTarget, target ?? "");
			}
			return false;
		}

		private static void ClearConfirmation()
		{
			_confirmAction = ConfirmAction.None;
			_confirmTarget = "";
		}

		private static bool CanAffectMember(ClanClientSnapshot snapshot, ClanPlayerSummary member)
		{
			if (snapshot.CanModerate && !member.IsSelf)
			{
				return ClanDataRules.GetRolePower(snapshot.SelfRole) > ClanDataRules.GetRolePower(member.Role);
			}
			return false;
		}

		private static string DirectoryStateText(ClanDirectoryPlayerSummary player)
		{
			return player.State switch
			{
				ClanDirectoryPlayerState.Clan => string.IsNullOrWhiteSpace(player.ClanName) ? ClanLocalization.Text("panel_state_clan") : player.ClanName, 
				ClanDirectoryPlayerState.Pending => ClanLocalization.Text("panel_state_pending_lower"), 
				ClanDirectoryPlayerState.Invited => ClanLocalization.Text("panel_state_invited"), 
				_ => "-", 
			};
		}

		private static Color DirectoryStateColor(ClanDirectoryPlayerState state)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(state switch
			{
				ClanDirectoryPlayerState.Pending => AccentColor, 
				ClanDirectoryPlayerState.Invited => new Color(0.56f, 0.78f, 1f, 1f), 
				ClanDirectoryPlayerState.Clan => Color.white, 
				_ => MutedColor, 
			});
		}

		private static string LastSeenText(ClanDirectoryPlayerSummary player)
		{
			if (player.IsOnline)
			{
				return ClanLocalization.Text("panel_last_seen_online");
			}
			if (player.LastSeenUtcTicks <= 0)
			{
				return ClanLocalization.Text("panel_last_seen_unknown");
			}
			TimeSpan timeSpan = DateTime.UtcNow - new DateTime(player.LastSeenUtcTicks, DateTimeKind.Utc);
			if (timeSpan.TotalHours < 24.0)
			{
				return ClanLocalization.Text("panel_last_seen_today");
			}
			return ClanLocalization.Format("panel_last_seen_days", Mathf.Clamp((int)timeSpan.TotalDays, 1, 28));
		}

		private static GameObject CreateTopRow(RectTransform content, float top, float height, bool alternate)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = ClanUiFactory.CreateObject("Row", (Transform)(object)content, typeof(Image));
			PlaceTop(obj.GetComponent<RectTransform>(), 3f, top, 406f, height);
			((Graphic)obj.GetComponent<Image>()).color = (alternate ? AlternateRowColor : RowColor);
			return obj;
		}

		private static ScrollRect CreateScrollView(Transform parent, string name, float x, float y, float width, float height, out RectTransform content, float normalizedPosition, Action<float> rememberPosition, float scrollbarTopInset = 0f)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: 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_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: 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_02ac: 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_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateRect(name, parent, x, y, width, height, typeof(Image), typeof(ScrollRect));
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(0f, 0f, 0f, 0.1f);
			((Graphic)component).raycastTarget = true;
			GameObject val2 = CreateRect("Viewport", val.transform, 0f, 0f, width, height, typeof(Image), typeof(Mask));
			Image component2 = val2.GetComponent<Image>();
			((Graphic)component2).color = Color.white;
			((Graphic)component2).raycastTarget = true;
			val2.GetComponent<Mask>().showMaskGraphic = false;
			GameObject val3 = ClanUiFactory.CreateObject("Content", val2.transform);
			content = val3.GetComponent<RectTransform>();
			content.anchorMin = new Vector2(0f, 1f);
			content.anchorMax = new Vector2(1f, 1f);
			content.pivot = new Vector2(0.5f, 1f);
			content.anchoredPosition = Vector2.zero;
			content.sizeDelta = new Vector2(0f, height);
			ScrollRect component3 = val.GetComponent<ScrollRect>();
			component3.content = content;
			component3.viewport = val2.GetComponent<RectTransform>();
			component3.horizontal = false;
			component3.vertical = true;
			component3.inertia = true;
			component3.decelerationRate = 0.12f;
			ClanUiFactory.ConfigureVerticalScroll(component3, hasOverflow: true);
			component3.verticalScrollbar = null;
			GameObject val4 = ClanUiFactory.CreateObject("Scrollbar", val.transform, typeof(Image), typeof(Scrollbar));
			RectTransform component4 = val4.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(1f, 0f);
			component4.anchorMax = new Vector2(1f, 1f);
			component4.pivot = new Vector2(1f, 0.5f);
			component4.offsetMin = new Vector2(-2f, 0f);
			component4.offsetMax = new Vector2(0f, 0f - Mathf.Clamp(scrollbarTopInset, 0f, height));
			((Graphic)val4.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.42f);
			GameObject obj = ClanUiFactory.CreateObject("Handle", val4.transform, typeof(Image));
			RectTransform component5 = obj.GetComponent<RectTransform>();
			component5.anchorMin = Vector2.zero;
			component5.anchorMax = Vector2.one;
			component5.offsetMin = Vector2.zero;
			component5.offsetMax = Vector2.zero;
			Image component6 = obj.GetComponent<Image>();
			((Graphic)component6).color = new Color(1f, 0.63f, 0.24f, 0.96f);
			Scrollbar component7 = val4.GetComponent<Scrollbar>();
			component7.handleRect = component5;
			((Selectable)component7).targetGraphic = (Graphic)(object)component6;
			component7.direction = (Direction)2;
			((Selectable)component7).transition = (Transition)0;
			component7.value = Mathf.Clamp01(normalizedPosition);
			component3.verticalScrollbar = component7;
			component3.verticalScrollbarVisibility = (ScrollbarVisibility)0;
			component3.verticalScrollbarSpacing = 0f;
			component3.verticalNormalizedPosition = Mathf.Clamp01(normalizedPosition);
			((UnityEvent<Vector2>)(object)component3.onValueChanged).AddListener((UnityAction<Vector2>)delegate(Vector2 value)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				rememberPosition(Mathf.Clamp01(value.y));
			});
			return component3;
		}

		private static void SetScrollContentHeight(ScrollRect scroll, RectTransform content, float requestedHeight, float viewportHeight)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			content.sizeDelta = new Vector2(0f, Mathf.Max(viewportHeight, requestedHeight));
			bool hasOverflow = requestedHeight > viewportHeight + 0.5f;
			ClanUiFactory.ConfigureVerticalScroll(scroll, hasOverflow);
		}

		private static Button CreateTopButton(Transform parent, string text, Action action, float x, float top, float width, float height, Color color, int fontSize)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			Button obj = CreateButtonObject(parent, text, action, color, fontSize);
			PlaceTop(((Component)obj).GetComponent<RectTransform>(), x, top, width, height);
			return obj;
		}

		private static Text CreateTopLabel(Transform parent, string text, float x, float top, float width, float height, int fontSize, TextAnchor alignment, Color color)
		{
			//IL_0004: 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)
			Text obj = CreateLabelObject(parent, text, fontSize, alignment, color);
			PlaceTop(((Component)obj).GetComponent<RectTransform>(), x, top, width, height);
			return obj;
		}

		private static Button CreateButton(Transform parent, string text, Action action, float x, float y, float width, float height, Color color, int fontSize)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			Button obj = CreateButtonObject(parent, text, action, color, fontSize);
			Place(((Component)obj).GetComponent<RectTransform>(), x, y, width, height);
			return obj;
		}

		private static Button CreateButtonObject(Transform parent, string text, Action action, Color color, int fontSize)
		{
			//IL_0033: 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_0065: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = ClanUiFactory.CreateObject("Button", parent, typeof(Image), typeof(Button));
			Image component = obj.GetComponent<Image>();
			((Graphic)component).color = color;
			((Graphic)component).raycastTarget = true;
			Button component2 = obj.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			((UnityEvent)component2.onClick).AddListener(new UnityAction(action.Invoke));
			Text obj2 = CreateLabelObject(obj.transform, text, fontSize, (TextAnchor)4, Color.white);
			RectTransform component3 = ((Component)obj2).GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.offsetMin = new Vector2(2f, 1f);
			component3.offsetMax = new Vector2(-2f, -1f);
			((Graphic)obj2).raycastTarget = false;
			TryApplyButtonStyle(component2, fontSize);
			SetButtonColor(component2, color);
			return component2;
		}

		private static Button CreateIconButton(Transform parent, ClanActionIcon icon, string tooltip, Action action, float x, float y, float width, float height, Color? color = null)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Button obj = CreateButton(parent, "", action, x, y, width, height, (Color)(((??)color) ?? ButtonColor), 10);
			ClanUiFeedback.ApplyIcon(obj, icon, tooltip, Mathf.Min(width, height) - 8f);
			return obj;
		}

		private static Text CreateLabel(Transform parent, string text, float x, float y, float width, float height, int fontSize, TextAnchor alignment, Color color)
		{
			//IL_0004: 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)
			Text obj = CreateLabelObject(parent, text, fontSize, alignment, color);
			Place(((Component)obj).GetComponent<RectTransform>(), x, y, width, height);
			return obj;
		}

		private static Text CreateLabelObject(Transform parent, string text, int fontSize, TextAnchor alignment, Color color)
		{
			//IL_0046: 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)
			Text component = ClanUiFactory.CreateObject("Text", parent, typeof(Text)).GetComponent<Text>();
			component.text = text ?? "";
			component.font = ClanUiFactory.GetBoldFont();
			component.fontSize = fontSize;
			component.alignment = alignment;
			((Graphic)component).color = color;
			component.supportRichText = false;
			component.horizontalOverflow = (HorizontalWrapMode)0;
			component.verticalOverflow = (VerticalWrapMode)0;
			((Graphic)component).raycastTarget = false;
			return component;
		}

		private static InputField CreateInputField(Transform parent, string name, string value, string placeholderValue, float x, float y, float width, float height, int characterLimit, int fontSize = 13)
		{
			//IL_004b: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateRect(name, parent, x, y, width, height, typeof(Image), typeof(InputField));
			Image component = obj.GetComponent<Image>();
			((Graphic)component).color = new Color(0.025f, 0.023f, 0.021f, 0.98f);
			((Graphic)component).raycastTarget = true;
			Text val = CreateLabel(obj.transform, value, 8f, 4f, width - 16f, height - 8f, fontSize, (TextAnchor)3, Color.white);
			((Object)val).name = "Text";
			((Graphic)val).raycastTarget = false;
			val.horizontalOverflow = (HorizontalWrapMode)0;
			Text val2 = CreateLabel(obj.transform, placeholderValue, 8f, 4f, width - 16f, height - 8f, fontSize, (TextAnchor)3, new Color(0.55f, 0.52f, 0.48f, 0.8f));
			((Object)val2).name = "Placeholder";
			val2.fontStyle = (FontStyle)2;
			((Graphic)val2).raycastTarget = false;
			InputField component2 = obj.GetComponent<InputField>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			component2.textComponent = val;
			component2.placeholder = (Graphic)(object)val2;
			component2.characterLimit = characterLimit;
			component2.lineType = (LineType)0;
			component2.text = value ?? "";
			component2.caretColor = Color.white;
			component2.selectionColor = new Color(0.28f, 0.62f, 0.56f, 0.55f);
			TryApplyInputFieldStyle(component2, fontSize);
			if ((Object)(object)component.sprite != (Object)null)
			{
				component.type = (Type)1;
			}
			return component2;
		}

		private static void AddEmblem(Transform parent, string emblemKey, float x, float y, float width, float height, string fallbackText)
		{
			//IL_005c: 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)
			Sprite emblemSprite = ClanEmoji.GetEmblemSprite(emblemKey);
			if ((Object)(object)emblemSprite != (Object)null)
			{
				AddSprite(parent, emblemSprite, x, y, width, height);
				return;
			}
			GameObject obj = CreateRect("ClanEmblemFallback", parent, x, y, width, height, typeof(Image));
			((Graphic)obj.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.28f);
			CreateLabel(text: string.IsNullOrWhiteSpace(fallbackText) ? "?" : fallbackText.Trim().Substring(0, 1).ToUpperInvariant(), parent: obj.transform, x: 0f, y: 0f, width: width, height: height, fontSize: Mathf.RoundToInt(Mathf.Min(width, height) * 0.42f), alignment: (TextAnchor)4, color: AccentColor);
		}

		private static void AddSprite(Transform parent, Sprite sprite, float x, float y, float width, float height)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			Image component = CreateRect("Icon", parent, x, y, width, height, typeof(Image)).GetComponent<Image>();
			component.sprite = sprite;
			((Graphic)component).color = Color.white;
			component.preserveAspect = true;
			((Graphic)component).raycastTarget = false;
		}

		private static GameObject CreateRect(string name, Transform parent, float x, float y, float width, float height, params Type[] components)
		{
			GameObject obj = ClanUiFactory.CreateObject(name, parent, components);
			Place(obj.GetComponent<RectTransform>(), x, y, width, height);
			return obj;
		}

		private static GameObject CreateWoodPanelObject(string name, Transform parent, float width, float height, bool draggable)
		{
			//IL_002c: 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_0056: 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_006d: 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)
			GameObject val = ClanUiFactory.CreateObject(name, parent, typeof(Image));
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = Vector2.zero;
			component.sizeDelta = new Vector2(width, height);
			Image component2 = val.GetComponent<Image>();
			try
			{
				GUIManager.Instance.ApplyWoodpanelStyle(val.transform);
			}
			catch (Exception ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Could not style " + name + " as a Valheim wood panel; using the fallback surface: " + ex.Message));
				component2.sprite = null;
				((Graphic)component2).material = null;
				component2.type = (Type)0;
				((Graphic)component2).color = PanelColor;
			}
			if (draggable)
			{
				val.AddComponent<DragWindowCntrl>();
			}
			return val;
		}

		private static void Place(RectTransform rect, float x, float y, float width, float height)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.zero;
			rect.pivot = Vector2.zero;
			rect.anchoredPosition = new Vector2(x, y);
			rect.sizeDelta = new Vector2(Mathf.Max(0f, width), Mathf.Max(0f, height));
		}

		private static void PlaceTop(RectTransform rect, float x, float top, float width, float height)
		{
			//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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(0f, 1f);
			rect.anchorMax = new Vector2(0f, 1f);
			rect.pivot = new Vector2(0f, 1f);
			rect.anchoredPosition = new Vector2(x, 0f - top);
			rect.sizeDelta = new Vector2(Mathf.Max(0f, width), Mathf.Max(0f, height));
		}

		private static void SetButtonColor(Button button, Color color)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Graphic targetGraphic = ((Selectable)button).targetGraphic;
			Image val = (Image)(object)((targetGraphic is Image) ? targetGraphic : null);
			if (val != null)
			{
				((Graphic)val).color = Color.white;
			}
			ColorBlock colors = ((Selectable)button).colors;
			((ColorBlock)(ref colors)).normalColor = color;
			((ColorBlock)(ref colors)).highlightedColor = Color.Lerp(color, AccentColor, 0.18f);
			((ColorBlock)(ref colors)).pressedColor = new Color(color.r * 0.72f, color.g * 0.72f, color.b * 0.72f, color.a);
			((ColorBlock)(ref colors)).selectedColor = Color.Lerp(color, AccentColor, 0.1f);
			((ColorBlock)(ref colors)).disabledColor = DisabledButtonColor;
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0.1f;
			((Selectable)button).colors = colors;
		}

		private static void SetPickerButtonState(Button button, bool selected, bool interactable)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			Color val = (selected ? ActivePickerButtonColor : PickerButtonColor);
			SetButtonColor(button, val);
			ColorBlock colors = ((Selectable)button).colors;
			((ColorBlock)(ref colors)).highlightedColor = Color.Lerp(val, Color.white, 0.28f);
			((ColorBlock)(ref colors)).pressedColor = new Color(val.r * 0.58f, val.g * 0.58f, val.b * 0.58f, val.a);
			((ColorBlock)(ref colors)).selectedColor = Color.Lerp(val, AccentColor, 0.16f);
			((ColorBlock)(ref colors)).disabledColor = DisabledPickerButtonColor;
			((Selectable)button).colors = colors;
			((Selectable)button).interactable = interactable;
			SetButtonContentColor(button, interactable ? Color.white : DisabledButtonLabelColor);
			if (interactable && !selected)
			{
				SetButtonLabelColor(button, InactiveButtonLabelColor);
			}
		}

		private static void SetButtonLabelColor(Button button, Color color)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Text[] componentsInChildren = ((Component)button).GetComponentsInChildren<Text>(true);
			foreach (Text val in componentsInChildren)
			{
				if ((Object)(object)((Component)val).transform.parent == (Object)(object)((Component)button).transform)
				{
					((Graphic)val).color = color;
				}
			}
		}

		private static void SetButtonContentColor(Button button, Color color)
		{
			//IL_0001: 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)
			SetButtonLabelColor(button, color);
			Image[] componentsInChildren = ((Component)button).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if ((Object)(object)((Component)val).transform.parent == (Object)(object)((Component)button).transform && (object)val != ((Selectable)button).targetGraphic)
				{
					((Graphic)val).color = color;
				}
			}
		}

		private static void RemoveButtonFrame(Button button)
		{
			Graphic targetGraphic = ((Selectable)button).targetGraphic;
			Image val = (Image)(object)((targetGraphic is Image) ? targetGraphic : null);
			if (val != null)
			{
				val.sprite = null;
				val.overrideSprite = null;
				((Graphic)val).material = null;
				val.type = (Type)0;
			}
		}

		private static void TryApplyButtonStyle(Button button, int fontSize)
		{
			try
			{
				GUIManager.Instance.ApplyButtonStyle(button, fontSize);
			}
			catch (Exception)
			{
			}
		}

		private static void TryApplyInputFieldStyle(InputField input, int fontSize)
		{
			try
			{
				GUIManager.Instance.ApplyInputFieldStyle(input, fontSize);
			}
			catch (Exception)
			{
			}
		}

		private static void PositionPanel()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_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_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: 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_0214: 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_0228: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_rootRect == (Object)null || (Object)(object)_overlayRoot == (Object)null)
			{
				return;
			}
			Rect safeArea = Screen.safeArea;
			if (((Rect)(ref safeArea)).width <= 0f || ((Rect)(ref safeArea)).height <= 0f)
			{
				((Rect)(ref safeArea))..ctor(0f, 0f, (float)Screen.width, (float)Screen.height);
			}
			Camera canvasCamera = ClanUiFactory.GetCanvasCamera((Component?)(object)_overlayRoot);
			Rect screenBounds = ClanUiFactory.GetScreenBounds(_overlayRoot, canvasCamera);
			if (_positionValid && ClanUiFactory.RectApproximately(_positionSafeArea, safeArea) && ClanUiFactory.RectApproximately(_positionOverlayBounds, screenBounds))
			{
				ClampCurrentPanelToSafeArea(safeArea, canvasCamera);
				return;
			}
			Vector2 center;
			if (!_positionValid)
			{
				center = ((Rect)(ref safeArea)).center;
			}
			else
			{
				Rect screenBounds2 = ClanUiFactory.GetScreenBounds(_rootRect, canvasCamera);
				center = ((Rect)(ref screenBounds2)).center;
			}
			Vector2 val = center;
			_positionValid = true;
			_positionSafeArea = safeArea;
			_positionOverlayBounds = screenBounds;
			((Transform)_rootRect).localScale = Vector3.one;
			Canvas.ForceUpdateCanvases();
			Rect screenBounds3 = ClanUiFactory.GetScreenBounds(_rootRect, canvasCamera);
			float num = Mathf.Max(1f, ((Rect)(ref screenBounds3)).width);
			float num2 = Mathf.Max(1f, ((Rect)(ref screenBounds3)).height);
			float num3 = Mathf.Max(1f, ((Rect)(ref safeArea)).width - 16f);
			float num4 = Mathf.Max(1f, ((Rect)(ref safeArea)).height - 16f);
			float num5 = Mathf.Min(new float[3]
			{
				2f,
				num3 / num,
				num4 / num2
			});
			num5 = Mathf.Max(0.05f, num5);
			((Transform)_rootRect).localScale = Vector3.one * num5;
			float num6 = num * num5;
			float num7 = num2 * num5;
			float num8 = num6 * 0.5f;
			float num9 = num7 * 0.5f;
			float num10 = Mathf.Clamp(val.x, ((Rect)(ref safeArea)).xMin + 8f + num8, ((Rect)(ref safeArea)).xMax - 8f - num8);
			float num11 = Mathf.Clamp(val.y, ((Rect)(ref safeArea)).yMin + 8f + num9, ((Rect)(ref safeArea)).yMax - 8f - num9);
			Vector3 position = default(Vector3);
			if (RectTransformUtility.ScreenPointToWorldPointInRectangle(_overlayRoot, new Vector2(num10, num11), canvasCamera, ref position))
			{
				((Transform)_rootRect).position = position;
			}
		}

		private static void ClampCurrentPanelToSafeArea(Rect safeArea, Camera? camera)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_rootRect == (Object)null) && !((Object)(object)_overlayRoot == (Object)null))
			{
				Rect screenBounds = ClanUiFactory.GetScreenBounds(_rootRect, camera);
				float num = ((Rect)(ref screenBounds)).width * 0.5f;
				float num2 = ((Rect)(ref screenBounds)).height * 0.5f;
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor(Mathf.Clamp(((Rect)(ref screenBounds)).center.x, ((Rect)(ref safeArea)).xMin + 8f + num, ((Rect)(ref safeArea)).xMax - 8f - num), Mathf.Clamp(((Rect)(ref screenBounds)).center.y, ((Rect)(ref safeArea)).yMin + 8f + num2, ((Rect)(ref safeArea)).yMax - 8f - num2));
				Vector2 val2 = val - ((Rect)(ref screenBounds)).center;
				Vector3 position = default(Vector3);
				if (!(((Vector2)(ref val2)).sqrMagnitude <= 0.01f) && RectTransformUtility.ScreenPointToWorldPointInRectangle(_overlayRoot, val, camera, ref position))
				{
					((Transform)_rootRect).position = position;
				}
			}
		}
	}
	internal static class ClanFriendlyFire
	{
		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		private static class DamagePatch
		{
			private static bool Prefix(Character __instance, HitData hit)
			{
				return !ShouldBlockDamage(__instance, hit);
			}
		}

		[HarmonyPatch(typeof(Aoe), "OnHit")]
		private static class FriendlyAoeScopePatch
		{
			private static void Prefix(Aoe __instance, Collider collider, out bool __state)
			{
				GameObject val = Projectile.FindHitObject(collider);
				__state = __instance.m_hitFriendly && (Object)(object)val != (Object)null && (Object)(object)val.GetComponent<Player>() != (Object)null;
				if (__state)
				{
					_friendlyAoeDepth++;
				}
			}

			private static Exception? Finalizer(Exception? __exception, bool __state)
			{
				if (__state)
				{
					_friendlyAoeDepth--;
				}
				return __exception;
			}
		}

		[HarmonyPatch(typeof(Character), "FindWeakSpotIndex")]
		private static class MarkFriendlyAoePatch
		{
			private static void Postfix(ref short __result)
			{
				if (_friendlyAoeDepth > 0)
				{
					__result = -23749;
				}
			}
		}

		private const short FriendlyAoeMarker = -23749;

		[ThreadStatic]
		private static int _friendlyAoeDepth;

		private static bool ShouldBlockDamage(Character target, HitData hit)
		{
			if (ClanPlugin.ClanFriendlyFire.Value.IsOn() || (Object)(object)target != (Object)(object)Player.m_localPlayer || hit.m_weakSpot == -23749)
			{
				return false;
			}
			Character attacker = hit.GetAttacker();
			Player val = (Player)(object)((attacker is Player) ? attacker : null);
			if (val == null || (Object)(object)val == (Object)(object)Player.m_localPlayer)
			{
				return false;
			}
			ClanPlayerRef player = ClanIdentity.FromPlayer(val);
			if (player.IsValid)
			{
				return ClanRpc.CurrentSnapshot.ContainsClanPlayer(player);
			}
			return false;
		}
	}
	internal static class ClanVanillaChatDock
	{
		private enum Channel
		{
			Say,
			Shout,
			Whisper,
			Clan
		}

		private enum CommandAction
		{
			None,
			ResetSpawn,
			Die
		}

		private enum ChatViewMode
		{
			All,
			Clan,
			Local,
			Global
		}

		private enum ChatLineKind
		{
			System,
			Clan,
			Local,
			Global
		}

		private readonly struct ChatLineKindScope
		{
			public ChatLineKind Previous { get; }

			public ChatLineKindScope(ChatLineKind previous)
			{
				Previous = previous;
			}
		}

		private readonly struct MouseCapturePatchState
		{
			public bool ReleaseRequested { get; }

			public bool OriginalMouseCapture { get; }

			public MouseCapturePatchState(bool releaseRequested, bool originalMouseCapture)
			{
				ReleaseRequested = releaseRequested;
				OriginalMouseCapture = originalMouseCapture;
			}
		}

		private sealed class ChatScaleDragHandle : MonoBehaviour, IPointerDownHandler, IEventSystemHandler, IPointerUpHandler, IBeginDragHandler, IDragHandler, IEndDragHandler
		{
			private bool _leftPointerDown;

			private bool _dragging;

			public void OnPointerDown(PointerEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				_leftPointerDown = (int)eventData.button == 0;
				if (_leftPointerDown)
				{
					_isChatScalePointerActive = true;
					_keepResizeCursorReleasedUntil = Time.unscaledTime + 0.2f;
				}
				RefocusChatInput();
				((AbstractEventData)eventData).Use();
			}

			public void OnPointerUp(PointerEventData eventData)
			{
				_leftPointerDown = false;
				_isChatScalePointerActive = false;
				_keepResizeCursorReleasedUntil = Time.unscaledTime + 0.2f;
				RefocusChatInput();
				((AbstractEventData)eventData).Use();
			}

			public void OnBeginDrag(PointerEventData eventData)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				if (_leftPointerDown && (int)eventData.button == 0)
				{
					_dragging = true;
					_isChatScalePointerActive = true;
					BeginChatScaleDrag();
					((AbstractEventData)eventData).Use();
				}
			}

			public void OnDrag(PointerEventData eventData)
			{
				//IL_0009: 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 (_dragging && (int)eventData.button == 0)
				{
					DragChatScale(eventData.delta);
					_keepResizeCursorReleasedUntil = Time.unscaledTime + 0.2f;
					((AbstractEventData)eventData).Use();
				}
			}

			public void OnEndDrag(PointerEventData eventData)
			{
				if (_dragging)
				{
					_dragging = false;
					_isChatScalePointerActive = false;
					_keepResizeCursorReleasedUntil = Time.unscaledTime + 0.2f;
					EndChatScaleDrag(save: true);
					((AbstractEventData)eventData).Use();
				}
			}

			private void OnDisable()
			{
				_leftPointerDown = false;
				_isChatScalePointerActive = false;
				_keepResizeCursorReleasedUntil = Time.unscaledTime + 0.2f;
				if (_dragging)
				{
					_dragging = false;
					EndChatScaleDrag(save: true);
				}
			}
		}

		private sealed class DockPointerFocusKeeper : MonoBehaviour, IPointerDownHandler, IEventSystemHandler, IPointerUpHandler, IPointerClickHandler
		{
			public void OnPointerDown(PointerEventData eventData)
			{
				KeepChatFocus(eventData);
			}

			public void OnPointerUp(PointerEventData eventData)
			{
				KeepChatFocus(eventData);
			}

			public void OnPointerClick(PointerEventData eventData)
			{
				KeepChatFocus(eventData);
			}

			private static void KeepChatFocus(PointerEventData eventData)
			{
				RefocusChatInput();
				((AbstractEventData)eventData).Use();
			}
		}

		[HarmonyPatch]
		private static class ChatLineKindPatch
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				yield return AccessTools.Method(typeof(Terminal), "AddString", new Type[4]
				{
					typeof(PlatformUserID),
					typeof(string),
					typeof(Type),
					typeof(bool)
				}, (Type[])null);
				yield return AccessTools.Method(typeof(Terminal), "AddString", new Type[4]
				{
					typeof(string),
					typeof(string),
					typeof(Type),
					typeof(bool)
				}, (Type[])null);
			}

			[HarmonyPriority(800)]
			private static void Prefix(Type type, out ChatLineKindScope __state)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				__state = PushChatLineKind(type);
			}

			private static Exception? Finalizer(Exception? __exception, ChatLineKindScope __state)
			{
				RestoreChatLineKind(__state);
				return __exception;
			}
		}

		[HarmonyPatch(typeof(Terminal), "AddString", new Type[] { typeof(string) })]
		private static class TrackChatLinePatch
		{
			[HarmonyPriority(800)]
			private static void Prefix(Terminal __instance)
			{
				PrepareTrackedChatLine(__instance);
			}
		}

		[HarmonyPatch(typeof(Terminal), "UpdateChat")]
		private static class ChatViewFilterPatch
		{
			[HarmonyPriority(0)]
			private static bool Prefix(Terminal __instance)
			{
				return !TryRenderFilteredChat(__instance);
			}
		}

		[HarmonyPatch(typeof(Chat), "Awake")]
		private static class ChatAwakePatch
		{
			private static void Postfix(Chat __instance)
			{
				try
				{
					RemoveVanillaStartupHelp(__instance);
				}
				catch (Exception ex)
				{
					ClanPlugin.ClanLogger.LogWarning((object)("Vanilla startup chat help removal was skipped: " + ex.GetBaseException().Message));
				}
				try
				{
					Rebuild();
				}
				catch (Exception ex2)
				{
					ClanPlugin.ClanLogger.LogWarning((object)("Clan chat controls will retry after Chat.Awake: " + ex2.GetBaseException().Message));
				}
			}
		}

		[HarmonyPatch(typeof(Chat), "InputText")]
		private static class RouteInputPatch
		{
			private static bool Prefix(Chat __instance)
			{
				if (!SupportsCurrentChatUi)
				{
					return true;
				}
				if (ClanPanelController.OwnsSelectedControl)
				{
					return false;
				}
				bool flag = ShouldRouteInput(__instance);
				bool flag2 = IsVanillaChatCommand(__instance);
				TMP_InputField inputField = GetInputField(__instance);
				bool flag3 = (Object)(object)inputField != (Object)null && !string.IsNullOrWhiteSpace(inputField.text) && !inputField.text.TrimStart(Array.Empty<char>()).StartsWith("/", StringComparison.Ordinal);
				if ((Object)(object)inputField != (Object)null && (flag3 || flag2) && !ClanEmoji.IsWithinMessageEmojiLimit(inputField.text))
				{
					ClanRpc.NotifyStatus(ClanLocalization.Format("chat_emoji_limit", ClanEmoji.MessageEmojiLimit));
					return false;
				}
				if (!flag)
				{
					if (flag2)
					{
						CompleteChatSubmission(__instance);
					}
					return true;
				}
				RouteInput(__instance);
				return false;
			}
		}

		[HarmonyPatch(typeof(Chat), "HasFocus")]
		private static class ChatHasFocusPatch
		{
			private static void Postfix(Chat __instance, ref bool __result)
			{
				if (SupportsCurrentChatUi)
				{
					__result |= ClanPanelController.CapturesGameplayInput || _clanPanelCancelFrame == Time.frameCount || HasPendingChatRefocus(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Menu), "Update")]
		private static class MenuUpdatePatch
		{
			private static bool Prefix()
			{
				if (!SupportsCurrentChatUi || Menu.IsVisible())
				{
					return true;
				}
				return _clanPanelCancelFrame != Time.frameCount && (!ClanPanelController.IsOpen || !ZInput.GetKeyDown((KeyCode)27, true));
			}
		}

		[HarmonyPatch(typeof(TMP_InputField), "ActivateInputField")]
		private static class ChatInputActivationPatch
		{
			private static bool Prefix(TMP_InputField __instance)
			{
				if (!SupportsCurrentChatUi)
				{
					return true;
				}
				TMP_InputField inputField = GetInputField();
				if (!((Object)(object)inputField == (Object)null) && !((Object)(object)__instance != (Object)(object)inputField))
				{
					return !ClanPanelController.OwnsFocusedTextInput;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(GameCamera), "UpdateMouseCapture")]
		private static class GameCameraCursorPatch
		{
			[HarmonyPriority(800)]
			private static void Prefix(ref bool ___m_mouseCapture, out MouseCapturePatchState __state)
			{
				bool flag = ShouldReleaseMouseCursor();
				__state = new MouseCapturePatchState(flag, ___m_mouseCapture);
				if (flag)
				{
					___m_mouseCapture = false;
				}
			}

			[HarmonyPriority(0)]
			private static void Postfix(ref bool ___m_mouseCapture, MouseCapturePatchState __state)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Invalid comparison between Unknown and I4
				if (__state.ReleaseRequested)
				{
					bool flag = ___m_mouseCapture;
					___m_mouseCapture = (flag ? (!__state.OriginalMouseCapture) : __state.OriginalMouseCapture);
				}
				if (__state.ReleaseRequested || ShouldReleaseMouseCursor())
				{
					if ((int)Cursor.lockState == 1)
					{
						Cursor.lockState = (CursorLockMode)0;
					}
					if (!Cursor.visible)
					{
						Cursor.visible = true;
					}
				}
			}

			private static Exception? Finalizer(ref bool ___m_mouseCapture, MouseCapturePatchState __state, Exception? __exception)
			{
				if (__exception != null && __state.ReleaseRequested)
				{
					___m_mouseCapture = __state.OriginalMouseCapture;
				}
				return __exception;
			}
		}

		[HarmonyPatch(typeof(Chat), "Update")]
		private static class ChatUpdatePatch
		{
			private static void Prefix(Chat __instance)
			{
				if (SupportsCurrentChatUi && ClanPanelController.IsOpen && _keepChatVisibleForClanPanel)
				{
					ResetChatHideTimer(__instance);
				}
			}

			[HarmonyPriority(0)]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				List<CodeInstruction> source = instructions.ToList();
				MethodInfo getKeyDown = AccessTools.Method(typeof(ZInput), "GetKeyDown", new Type[2]
				{
					typeof(KeyCode),
					typeof(bool)
				}, (Type[])null);
				MethodInfo getKey = AccessTools.Method(typeof(ZInput), "GetKey", new Type[2]
				{
					typeof(KeyCode),
					typeof(bool)
				}, (Type[])null);
				int matchedKeyReads = 0;
				for (int index = 0; index < source.Count; index++)
				{
					CodeInstruction instruction = source[index];
					yield return instruction;
					if (!(instruction.opcode != OpCodes.Ldc_I4) && instruction.operand is int num && (num == 323 || num == 324) && index + 2 < source.Count && !(source[index + 1].opcode != OpCodes.Ldc_I4_1) && ((getKeyDown != null && CodeInstructionExtensions.Calls(source[index + 2], getKeyDown)) || (getKey != null && CodeInstructionExtensions.Calls(source[index + 2], getKey))))
					{
						matchedKeyReads++;
						yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ClanVanillaChatDock), "FilterChatMouseKeyCode", (Type[])null, (Type[])null));
					}
				}
				if (matchedKeyReads == 2 || matchedKeyReads == 0)
				{
					ClanPlugin.ClanLogger.LogDebug((object)((matchedKeyReads == 0) ? "Another patch or game version already handles Chat mouse-close input." : $"Chat mouse input patch matched {matchedKeyReads} key reads."));
				}
				else
				{
					ClanPlugin.ClanLogger.LogWarning((object)$"Chat mouse input patch matched {matchedKeyReads}/{2} expected key reads; clicking Clan UI may close chat.");
				}
			}
		}

		private const float EdgeGap = 4f;

		private const float FeatureDockWidth = 66f;

		private const float ChannelButtonHeight = 30f;

		private const float ChannelButtonSpacing = 4f;

		private const float FeatureDockHeight = 40f;

		private const float ChannelDockHeight = 40f;

		private const float ShoutButtonWidth = 74f;

		private const float ClanChatButtonWidth = 104f;

		private const float WhisperButtonWidth = 86f;

		private const float ResetSpawnButtonWidth = 104f;

		private const float DieButtonWidth = 54f;

		private const int EmojiColumnCount = 5;

		private const int EmojiVisibleRowCount = 5;

		private const int MinimumEmojiVisibleRowCount = 1;

		private const float EmojiCellSize = 52f;

		private const float EmojiCellSpacing = 4f;

		private const float EmojiTrayPadding = 6f;

		private const float EmojiScrollbarWidth = 2f;

		private const float ScrollOverflowEpsilon = 0.5f;

		private const float EmojiTrayWidth = 288f;

		private const float EmojiTrayHeight = 288f;

		private const float ResizeHandleSize = 42f;

		private const float ResizeIconSize = 28f;

		private const float MinimumChatScale = 1f;

		private const float FallbackChatInputWidth = 500f;

		private const float FallbackChatInputHeight = 36f;

		private const float MaximumChatScale = 2f;

		private const float ResizeCursorReleaseGrace = 0.2f;

		private const float CommandConfirmationSeconds = 3f;

		private const int ChatRefocusTimeoutFrames = 4;

		private const int MaximumTrackedChatLines = 300;

		private static readonly Dictionary<Channel, Button> ChannelButtons = new Dictionary<Channel, Button>();

		private static readonly Vector3[] WorldCornersA = (Vector3[])(object)new Vector3[4];

		private static readonly Vector3[] WorldCornersB = (Vector3[])(object)new Vector3[4];

		private static readonly Color DockBackgroundColor = new Color(0f, 0f, 0f, 0.34f);

		private static readonly Color ButtonColor = new Color(0.78f, 0.78f, 0.78f, 0.96f);

		private static readonly Color ActiveToggleButtonColor = new Color(1f, 1f, 1f, 0.95f);

		private static readonly Color InactiveToggleButtonColor = new Color(0.5f, 0.5f, 0.5f, 0.95f);

		private static readonly Color DisabledButtonColor = new Color(0.25f, 0.25f, 0.25f, 0.72f);

		private static readonly Color ButtonHoverColor = new Color(1f, 0.72f, 0.32f, 1f);

		private static readonly Color ConfirmationButtonColor = new Color(1f, 0.48f, 0.24f, 1f);

		private static readonly Color InactiveButtonLabelColor = Color.gray;

		private static readonly Color DisabledButtonLabelColor = new Color(0.4f, 0.4f, 0.4f, 0.9f);

		private static GameObject? _root;

		private static GameObject? _chatChromeRoot;

		private static RectTransform? _rootRect;

		private static RectTransform? _emojiButtonDockRect;

		private static RectTransform? _clanButtonDockRect;

		private static RectTransform? _chatViewDockRect;

		private static RectTransform? _channelDockRect;

		private static RectTransform? _commandDockRect;

		private static RectTransform? _emojiTrayRect;

		private static RectTransform? _resizeHandleRect;

		private static RectTransform? _chatPanelRect;

		private static CanvasGroup? _clanButtonDockCanvasGroup;

		private static bool? _clanButtonDockInteractive;

		private static bool _canResizeChatPanel;

		private static GameObject? _emojiTray;

		private static RectTransform? _emojiContent;

		private static Button? _clanPanelButton;

		private static Text? _clanPanelButtonLabel;

		private static Button? _emojiTrayButton;

		private static Button? _chatViewButton;

		private static Button? _whisperButton;

		private static Button? _resetSpawnButton;

		private static Button? _dieButton;

		private static Channel _activeChannel = Channel.Say;

		private static bool _emojiTrayOpen;

		private static float _nextAttachAttempt;

		private static RectTransform? _chatScaleTarget;

		private static Vector3 _chatBaseLocalScale = Vector3.one;

		private static float _chatScaleFactor = 1f;

		private static bool _hasCachedChatInputBounds;

		private static Rect _cachedChatInputBounds;

		private static float _cachedChatDockScale = 1f;

		private static int _chatPlacementCacheScreenWidth;

		private static int _chatPlacementCacheScreenHeight;

		private static Rect _chatPlacementCacheSafeArea;

		private static float _chatPlacementCacheConfiguredScale;

		private static float _chatPlacementCacheCanvasScaleFactor;

		private static int _chatPlacementCacheCanvasId;

		private static int _chatPlacementCacheInputId;

		private static bool _hasCachedClanDockPlacement;

		private static Vector2 _cachedClanDockScreenPoint;

		private static Vector2 _cachedClanDockPivot;

		private static Vector3 _cachedClanDockLocalScale = Vector3.one;

		private static int _clanDockCacheScreenWidth;

		private static int _clanDockCacheScreenHeight;

		private static Rect _clanDockCacheSafeArea;

		private static float _clanDockCacheConfiguredScale;

		private static int _clanDockCacheChatId;

		private static int _clanDockCacheInputId;

		private static bool _isChatScaleDragging;

		private static bool _isChatScalePointerActive;

		private static float _keepResizeCursorReleasedUntil;

		private static int _chatRefocusFrame = -1;

		private static int _chatRefocusDeadlineFrame = -1;

		private static int _emojiShortcutFocusFrame = -1;

		private static int _clanPanelCancelFrame = -1;

		private static Chat? _chatRefocusOwner;

		private static CommandAction _pendingCommand;

		private static float _commandConfirmationExpiresAt;

		private static Chat? _unsupportedChatWarningOwner;

		private static Chat? _trackedChat;

		private static ChatViewMode _chatViewMode = ChatViewMode.All;

		private static readonly List<ChatLineKind> ChatLineKinds = new List<ChatLineKind>();

		[ThreadStatic]
		private static ChatLineKind _scopedChatLineKind;

		private static bool _chatHistoryMismatchWarned;

		private static bool _chatFilterUnavailableWarned;

		private static bool _keepChatVisibleForClanPanel;

		private static bool _reopenPanelAfterRebuild;

		private static bool _keepChatVisibleAfterPanelRebuild;

		private static bool _shortcutSettingSubscribed;

		private static readonly FieldInfo? ChatBufferField = AccessTools.Field(typeof(Terminal), "m_chatBuffer");

		private static readonly FieldInfo? ChatScrollHeightField = AccessTools.Field(typeof(Terminal), "m_scrollHeight");

		private static readonly FieldInfo? ChatVisibleBufferLengthField = AccessTools.Field(typeof(Terminal), "m_maxVisibleBufferLength");

		private static readonly MethodInfo? TerminalUpdateChatMethod = AccessTools.Method(typeof(Terminal), "UpdateChat", (Type[])null, (Type[])null);

		private static FieldRef<Chat, float>? _chatHideTimer = CreateChatHideTimerAccessor();

		internal static bool SupportsCurrentChatUi
		{
			get
			{
				Chat instance = Chat.instance;
				if ((Object)(object)instance != (Object)null)
				{
					return !IsUnsupportedReplacementChat(instance);
				}
				return false;
			}
		}

		public static void Init()
		{
			GUIManager.OnCustomGUIAvailable += Rebuild;
			ClanRpc.SnapshotChanged += OnSnapshotChanged;
			ClanRpc.DirectoryChanged += OnDirectoryChanged;
			ClanRpc.StatusReceived += OnStatusReceived;
			ClanRpc.ChatReceived += OnClanChatReceived;
			ClanEmoji.EmojiChanged += OnEmojiChanged;
			ClanEmoji.EmblemsChanged += OnEmblemsChanged;
			ClanPanelController.OpenStateChanged += OnClanPanelOpenStateChanged;
			ClanLocalization.LanguageChanged += OnLanguageChanged;
			ClanPlugin.ClanPanelShortcut.SettingChanged += OnPanelShortcutChanged;
			ClanPlugin.EmojiPanelShortcut.SettingChanged += OnPanelShortcutChanged;
			_shortcutSettingSubscribed = true;
			Rebuild();
		}

		public static void Dispose()
		{
			GUIManager.OnCustomGUIAvailable -= Rebuild;
			ClanRpc.SnapshotChanged -= OnSnapshotChanged;
			ClanRpc.DirectoryChanged -= OnDirectoryChanged;
			ClanRpc.StatusReceived -= OnStatusReceived;
			ClanRpc.ChatReceived -= OnClanChatReceived;
			ClanEmoji.EmojiChanged -= OnEmojiChanged;
			ClanEmoji.EmblemsChanged -= OnEmblemsChanged;
			ClanPanelController.OpenStateChanged -= OnClanPanelOpenStateChanged;
			ClanLocalization.LanguageChanged -= OnLanguageChanged;
			if (_shortcutSettingSubscribed)
			{
				ClanPlugin.ClanPanelShortcut.SettingChanged -= OnPanelShortcutChanged;
				ClanPlugin.EmojiPanelShortcut.SettingChanged -= OnPanelShortcutChanged;
				_shortcutSettingSubscribed = false;
			}
			ReleaseChatScaleTarget(restoreScale: true);
			DestroyRoot();
			ResetChatHistoryTracking(null);
			_clanPanelCancelFrame = -1;
			_unsupportedChatWarningOwner = null;
		}

		public static void Tick()
		{
			if ((Object)(object)ZNet.instance == (Object)null || (Object)(object)Chat.instance == (Object)null)
			{
				ResetChatPlacementCache();
			}
			if ((Object)(object)ZNet.instance == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)Chat.instance == (Object)null)
			{
				DestroyRoot();
				return;
			}
			Chat instance = Chat.instance;
			if (IsUnsupportedReplacementChat(instance))
			{
				DisableDockForUnsupportedChat(instance);
				return;
			}
			_unsupportedChatWarningOwner = null;
			if ((Object)(object)_root == (Object)null && Time.time >= _nextAttachAttempt)
			{
				_nextAttachAttempt = Time.time + 1f;
				Rebuild();
			}
			if ((Object)(object)_root == (Object)null)
			{
				return;
			}
			RefreshConfiguredChannelVisibility();
			RefreshConfiguredCommandVisibility();
			ExpireCommandConfirmation();
			if ((_isChatScalePointerActive || _isChatScaleDragging) && !Input.GetMouseButton(0))
			{
				_isChatScalePointerActive = false;
				_keepResizeCursorReleasedUntil = Time.unscaledTime + 0.2f;
				EndChatScaleDrag(save: true);
			}
			TMP_InputField inputField = GetInputField();
			if ((Object)(object)inputField == (Object)null)
			{
				CancelPendingChatRefocus();
				CloseOverlays();
				_root.SetActive(false);
				return;
			}
			bool num = TryHandleClanPanelCancel();
			bool flag = false;
			if (!num && ShouldToggleClanPanelFromShortcut(instance, inputField))
			{
				ToggleClanPanel(IsChatInputOpen(inputField));
				flag = true;
			}
			if (!num && !flag && ShouldOpenEmojiTrayFromShortcut(instance, inputField))
			{
				OpenEmojiTrayFromShortcut(instance, inputField);
			}
			ApplyPendingEmojiShortcutFocus(inputField);
			ApplyPendingChatRefocus(inputField);
			bool isOpen = ClanPanelController.IsOpen;
			if (isOpen && _keepChatVisibleForClanPanel)
			{
				KeepChatOpenForClanPanel(inputField);
			}
			bool flag2 = IsChatInputOpen(inputField);
			if (!flag2)
			{
				if (isOpen)
				{
					CloseChatOverlays();
				}
				else
				{
					CloseOverlays();
				}
			}
			ClanClientSnapshot currentSnapshot = ClanRpc.CurrentSnapshot;
			RefreshClanNotificationPulse(currentSnapshot);
			bool flag3 = ShouldShowStandaloneClanNotification(currentSnapshot, flag2, isOpen);
			bool flag4 = flag2 || isOpen || flag3;
			_root.SetActive(flag4);
			if ((Object)(object)_chatChromeRoot != (Object)null)
			{
				_chatChromeRoot.SetActive(flag2);
			}
			SetClanButtonDockVisibility(flag2, flag3);
			if (!flag4)
			{
				return;
			}
			if (flag2)
			{
				RefreshDockPositions(inputField);
			}
			else if (flag3)
			{
				if ((Object)(object)_rootRect != (Object)null)
				{
					PlaceStandaloneClanNotification(_rootRect);
				}
			}
			else if ((Object)(object)_rootRect != (Object)null)
			{
				ClanPanelController.RefreshPosition(_rootRect);
			}
			ClanPanelController.Tick();
		}

		private static void Rebuild()
		{
			Rebuild(_reopenPanelAfterRebuild);
		}

		private static void Rebuild(bool preservePanelInteractionState)
		{
			if (GUIManager.IsHeadless() || (Object)(object)Chat.instance == (Object)null)
			{
				return;
			}
			Chat instance = Chat.instance;
			if (IsUnsupportedReplacementChat(instance))
			{
				DisableDockForUnsupportedChat(instance);
				return;
			}
			_unsupportedChatWarningOwner = null;
			EnsureTrackedChat((Terminal)(object)instance);
			TMP_InputField inputField = GetInputField(instance);
			if ((Object)(object)inputField == (Object)null)
			{
				return;
			}
			bool flag = preservePanelInteractionState || _reopenPanelAfterRebuild;
			try
			{
				DestroyRoot(flag);
				RectTransform component = ((Component)inputField).GetComponent<RectTransform>();
				_chatPanelRect = ResolveChatPanelRect(component);
				_canResizeChatPanel = CanResizeDeclaredChatWindow(component, _chatPanelRect);
				RefreshChatScaleTarget(_chatPanelRect, _canResizeChatPanel);
				Transform overlayParent = GetOverlayParent(component);
				_root = ClanUiFactory.CreateObject("ClanVanillaChatDock", overlayParent);
				_root.AddComponent<LayoutElement>().ignoreLayout = true;
				RectTransform val = (_rootRect = _root.GetComponent<RectTransform>());
				StretchRoot(val);
				_root.transform.SetAsLastSibling();
				_chatChromeRoot = ClanUiFactory.CreateObject("ClanVanillaChatChrome", _root.transform);
				StretchRoot(_chatChromeRoot.GetComponent<RectTransform>());
				BuildChannelDock(_chatChromeRoot.transform, _root.transform);
				BuildCommandDock(_chatChromeRoot.transform);
				BuildEmojiTray(_chatChromeRoot.transform);
				ClanPanelController.Build(_root.transform, val, flag);
				BuildResizeHandle(_chatChromeRoot.transform);
				ApplyClanDockScale();
				RefreshDockPositions(inputField);
				RefreshUi(ClanRpc.CurrentSnapshot);
				ClanPanelController.RefreshDirectory(ClanRpc.CurrentDirectory);
				RestorePanelAfterRebuild();
				bool flag2 = IsChatInputOpen(inputField);
				bool isOpen = ClanPanelController.IsOpen;
				bool flag3 = ShouldShowStandaloneClanNotification(ClanRpc.CurrentSnapshot, flag2, isOpen);
				if (flag3 && (Object)(object)_rootRect != (Object)null)
				{
					PlaceStandaloneClanNotification(_rootRect);
				}
				_chatChromeRoot.SetActive(flag2);
				SetClanButtonDockVisibility(flag2, flag3);
				_root.SetActive(flag2 || isOpen || flag3);
			}
			catch
			{
				DestroyRoot(flag);
				throw;
			}
		}

		private static void OnLanguageChanged()
		{
			if (ClanPanelController.IsOpen)
			{
				_reopenPanelAfterRebuild = true;
				_keepChatVisibleAfterPanelRebuild = _keepChatVisibleForClanPanel;
			}
			Rebuild(_reopenPanelAfterRebuild);
		}

		private static void RestorePanelAfterRebuild()
		{
			if (_reopenPanelAfterRebuild)
			{
				if (!ClanPanelController.IsOpen)
				{
					ClanPanelController.Toggle();
				}
				_keepChatVisibleForClanPanel = _keepChatVisibleAfterPanelRebuild;
				_reopenPanelAfterRebuild = false;
				_keepChatVisibleAfterPanelRebuild = false;
			}
		}

		private static void ClearPanelRebuildRecovery()
		{
			_reopenPanelAfterRebuild = false;
			_keepChatVisibleAfterPanelRebuild = false;
		}

		private static void DestroyRoot(bool preservePanelInteractionState = false)
		{
			if (!preservePanelInteractionState)
			{
				ClearPanelRebuildRecovery();
			}
			if (_isChatScaleDragging)
			{
				EndChatScaleDrag(save: true);
			}
			ClearClanButtonDockSelection();
			GameObject root = _root;
			_root = null;
			_chatChromeRoot = null;
			_keepChatVisibleForClanPanel = false;
			if ((Object)(object)root != (Object)null)
			{
				root.SetActive(false);
			}
			_emojiTrayOpen = false;
			_rootRect = null;
			_emojiButtonDockRect = null;
			_clanButtonDockRect = null;
			_chatViewDockRect = null;
			_channelDockRect = null;
			_commandDockRect = null;
			_emojiTrayRect = null;
			_resizeHandleRect = null;
			_chatPanelRect = null;
			_clanButtonDockCanvasGroup = null;
			_clanButtonDockInteractive = null;
			_emojiTray = null;
			_emojiContent = null;
			_clanPanelButton = null;
			_clanPanelButtonLabel = null;
			_emojiTrayButton = null;
			_chatViewButton = null;
			_whisperButton = null;
			_resetSpawnButton = null;
			_dieButton = null;
			_pendingCommand = CommandAction.None;
			_commandConfirmationExpiresAt = 0f;
			_canResizeChatPanel = false;
			_isChatScaleDragging = false;
			_isChatScalePointerActive = false;
			_keepResizeCursorReleasedUntil = 0f;
			_emojiShortcutFocusFrame = -1;
			CancelPendingChatRefocus();
			ChannelButtons.Clear();
			ClanPanelController.DestroyView(preservePanelInteractionState);
			if ((Object)(object)root != (Object)null)
			{
				Object.Destroy((Object)(object)root);
			}
		}

		private static void CloseOverlays()
		{
			CloseEmojiTray();
			ClanPanelController.Close();
			CancelCommandConfirmation();
			RefreshButtonStates();
		}

		private static void CloseChatOverlays()
		{
			bool emojiTrayOpen = _emojiTrayOpen;
			CloseEmojiTray();
			CancelCommandConfirmation();
			if (emojiTrayOpen)
			{
				RefreshButtonStates();
			}
		}

		private static void CloseEmojiTray()
		{
			bool emojiTrayOpen = _emojiTrayOpen;
			_emojiTrayOpen = false;
			if ((Object)(object)_emojiTray != (Object)null)
			{
				_emojiTray.SetActive(false);
			}
			if (emojiTrayOpen)
			{
				_emojiShortcutFocusFrame = -1;
				RefreshEmojiPanelTooltip();
			}
		}

		private static KeyCode FilterChatMouseKeyCode(KeyCode keyCode)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			if (IsPointerOverDock() && ((int)keyCode == 323 || (int)keyCode == 324))
			{
				return (KeyCode)0;
			}
			return keyCode;
		}

		private static bool IsPointerOverDock()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_0073: 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_0083: 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)
			if (!SupportsCurrentChatUi)
			{
				return false;
			}
			Vector2 pointerPosition = Vector2.op_Implicit(Input.mousePosition);
			if (!ContainsPointer(_emojiButtonDockRect, pointerPosition) && (!((Object)(object)_clanPanelButton != (Object)null) || !((Selectable)_clanPanelButton).interactable || !ContainsPointer(_clanButtonDockRect, pointerPosition)) && !ContainsPointer(_chatViewDockRect, pointerPosition) && !ContainsPointer(_channelDockRect, pointerPosition) && !ContainsPointer(_commandDockRect, pointerPosition) && !ContainsPointer(_emojiTrayRect, pointerPosition) && !ClanPanelController.ContainsPointer(pointerPosition) && !ClanHud.CapturesChatPointer(pointerPosition))
			{
				return ContainsPointer(_resizeHandleRect, pointerPosition);
			}
			return true;
		}

		private static bool IsChatInputOpen(TMP_InputField input)
		{
			if (((Component)input).gameObject.activeInHierarchy && ((Behaviour)input).isActiveAndEnabled)
			{
				return ((Selectable)input).interactable;
			}
			return false;
		}

		private static bool HasActionableClanNotification(ClanClientSnapshot snapshot)
		{
			if (snapshot.Invite == null)
			{
				if (snapshot.CanModerate)
				{
					return snapshot.Applications.Count > 0;
				}
				return false;
			}
			return true;
		}

		private static bool ShouldShowStandaloneClanNotification(ClanClientSnapshot snapshot, bool chatInputVisible, bool panelOpen)
		{
			if (HasActionableClanNotification(snapshot) && !chatInputVisible && !panelOpen)
			{
				return !IsBlockingModalVisible();
			}
			return false;
		}

		private static bool IsBlockingModalVisible()
		{
			if (!Console.IsVisible() && !TextInput.IsVisible() && !Minimap.InTextInput() && !Minimap.IsOpen() && !Menu.IsVisible() && !InventoryGui.IsVisible() && !StoreGui.IsVisible())
			{
				return UnifiedPopup.IsVisible();
			}
			return true;
		}

		private static void SetClanButtonDockVisibility(bool chatInputVisible, bool showStandaloneNotification)
		{
			if ((Object)(object)_clanButtonDockRect == (Object)null)
			{
				return;
			}
			bool active = chatInputVisible || showStandaloneNotification;
			((Component)_clanButtonDockRect).gameObject.SetActive(active);
			if ((Object)(object)_clanButtonDockCanvasGroup != (Object)null)
			{
				_clanButtonDockCanvasGroup.alpha = 1f;
				_clanButtonDockCanvasGroup.interactable = chatInputVisible;
				_clanButtonDockCanvasGroup.blocksRaycasts = chatInputVisible;
				_clanButtonDockCanvasGroup.ignoreParentGroups = false;
			}
			if ((Object)(object)_clanPanelButton != (Object)null)
			{
				((Selectable)_clanPanelButton).interactable = chatInputVisible;
			}
			if (_clanButtonDockInteractive == chatInputVisible)
			{
				return;
			}
			_clanButtonDockInteractive = chatInputVisible;
			if (chatInputVisible)
			{
				RefreshClanPanelTooltip();
				return;
			}
			if ((Object)(object)_clanPanelButton != (Object)null)
			{
				ClanUiFeedback.SetTooltip((Selectable)(object)_clanPanelButton, "");
			}
			ClearClanButtonDockSelection();
		}

		private static void ClearClanButtonDockSelection()
		{
			EventSystem current = EventSystem.current;
			GameObject val = ((current != null) ? current.currentSelectedGameObject : null);
			if ((Object)(object)current != (Object)null && (Object)(object)val != (Object)null && (Object)(object)_clanButtonDockRect != (Object)null && ((Object)(object)val == (Object)(object)((Component)_clanButtonDockRect).gameObject || val.transform.IsChildOf((Transform)(object)_clanButtonDockRect)))
			{
				current.SetSelectedGameObject((GameObject)null);
			}
		}

		private static bool ShouldReleaseMouseCursor()
		{
			//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 (!SupportsCurrentChatUi || !ZInput.IsMouseActive())
			{
				return false;
			}
			Chat instance = Chat.instance;
			if ((Object)(object)instance != (Object)null && HasPendingChatRefocus(instance))
			{
				return true;
			}
			if (ClanHud.CapturesChatPointer(Vector2.op_Implicit(Input.mousePosition)))
			{
				return true;
			}
			if ((Object)(object)_root == (Object)null || !_root.activeInHierarchy)
			{
				return false;
			}
			if (ClanPanelController.CapturesGameplayInput)
			{
				return true;
			}
			TMP_InputField inputField = GetInputField();
			if ((Object)(object)inputField != (Object)null && IsChatInputOpen(inputField))
			{
				if (!inputField.isFocused && !_emojiTrayOpen && !_isChatScalePointerActive)
				{
					return Time.unscaledTime < _keepResizeCursorReleasedUntil;
				}
				return true;
			}
			return false;
		}

		private static void KeepChatOpenForClanPanel(TMP_InputField input)
		{
			Chat instance = Chat.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				EnsureChatVisible(instance, input);
			}
		}

		private static bool ContainsPointer(RectTransform? rect, Vector2 pointerPosition)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rect != (Object)null && ((Component)rect).gameObject.activeInHierarchy)
			{
				return RectTransformUtility.RectangleContainsScreenPoint(rect, pointerPosition, (Camera)null);
			}
			return false;
		}

		private static Transform GetOverlayParent(RectTransform inputRect)
		{
			if ((Object)(object)GUIManager.CustomGUIFront != (Object)null)
			{
				return GUIManager.CustomGUIFront.transform;
			}
			Canvas componentInParent = ((Component)inputRect).GetComponentInParent<Canvas>(true);
			if (!((Object)(object)componentInParent != (Object)null))
			{
				return ((Transform)inputRect).root;
			}
			return ((Component)componentInParent).transform;
		}

		private static RectTransform? ResolveChatPanelRect(RectTransform inputRect)
		{
			if (!((Object)(object)Chat.instance == (Object)null))
			{
				return ResolveDeclaredChatContentRoot(inputRect, ((Terminal)Chat.instance).m_chatWindow);
			}
			return null;
		}

		private static bool CanResizeDeclaredChatWindow(RectTransform inputRect, RectTransform? target)
		{
			if ((Object)(object)Chat.instance == (Object)null || (Object)(object)target == (Object)null)
			{
				return false;
			}
			RectTransform chatWindow = ((Terminal)Chat.instance).m_chatWindow;
			if ((Object)(object)ResolveDeclaredChatContentRoot(inputRect, chatWindow) == (Object)(object)target)
			{
				return (Object)(object)chatWindow != (Object)null;
			}
			return false;
		}

		private static RectTransform? ResolveDeclaredChatContentRoot(RectTransform inputRect, RectTransform? declaredWindow)
		{
			if ((Object)(object)declaredWindow == (Object)null || ((Object)(object)inputRect != (Object)(object)declaredWindow && !((Component)inputRect).transform.IsChildOf(((Component)declaredWindow).transform)))
			{
				return null;
			}
			TextMeshProUGUI output = ((Terminal)Chat.instance).m_output;
			RectTransform val = ((output != null) ? ((Component)output).GetComponent<RectTransform>() : null);
			if ((Object)(object)val == (Object)null || ((Object)(object)val != (Object)(object)declaredWindow && !((Component)val).transform.IsChildOf(((Component)declaredWindow).transform)))
			{
				return null;
			}
			Transform val2 = ((Component)inputRect).transform;
			while ((Object)(object)val2 != (Object)null)
			{
				RectTransform val3 = (RectTransform)(object)((val2 is RectTransform) ? val2 : null);
				if (val3 != null && ((Object)(object)val == (Object)(object)val3 || ((Component)val).transform.IsChildOf(((Component)val3).transform)))
				{
					return val3;
				}
				if ((Object)(object)val2 == (Object)(object)((Component)declaredWindow).transform)
				{
					break;
				}
				val2 = val2.parent;
			}
			return null;
		}

		private static void StretchRoot(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.pivot = new Vector2(0.5f, 0.5f);
			rect.offsetMin = Vector2.zero;
			rect.offsetMax = Vector2.zero;
		}

		private static void BuildChannelDock(Transform parent, Transform persistentParent)
		{
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Expected O, but got Unknown
			_emojiButtonDockRect = BuildRailButtonDock(parent, "ClanDockEmoji", ClanLocalization.Text("chat_button_emoji"), ToggleEmojiTray, out _emojiTrayButton);
			RefreshEmojiPanelTooltip();
			_clanButtonDockRect = BuildRailButtonDock(persistentParent, "ClanDockClan", ClanLocalization.Text("chat_button_clan"), ToggleClanPanelFromDock, out _clanPanelButton);
			_clanPanelButtonLabel = ((Component)_clanPanelButton).GetComponentInChildren<Text>(true);
			_clanButtonDockCanvasGroup = ((Component)_clanButtonDockRect).gameObject.AddComponent<CanvasGroup>();
			RefreshClanPanelTooltip();
			_chatViewDockRect = BuildRailButtonDock(parent, "ClanDockViewFilter", GetChatViewPresentation().Label, CycleChatViewMode, out _chatViewButton);
			RefreshChatViewButton(refreshTooltip: true);
			GameObject obj = ClanUiFactory.CreateObject("ClanDockChannels", parent, typeof(Image), typeof(HorizontalLayoutGroup), typeof(ContentSizeFitter), typeof(DockPointerFocusKeeper));
			RectTransform val = (_channelDockRect = obj.GetComponent<RectTransform>());
			val.anchorMin = new Vector2(0.5f, 0.5f);
			val.anchorMax = new Vector2(0.5f, 0.5f);
			val.sizeDelta = new Vector2(196f, 40f);
			((Graphic)obj.GetComponent<Image>()).color = DockBackgroundColor;
			HorizontalLayoutGroup component = obj.GetComponent<HorizontalLayoutGroup>();
			((LayoutGroup)component).padding = new RectOffset(5, 5, 5, 5);
			((HorizontalOrVerticalLayoutGroup)component).spacing = 4f;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			ContentSizeFitter component2 = obj.GetComponent<ContentSizeFitter>();
			component2.horizontalFit = (FitMode)2;
			component2.verticalFit = (FitMode)0;
			AddChannelButton(obj.transform, Channel.Shout, ClanLocalization.Text("chat_channel_shout"), 74f);
			AddChannelButton(obj.transform, Channel.Clan, ClanLocalization.Text("chat_channel_clan"), 104f);
			_whisperButton = AddChannelButton(obj.transform, Channel.Whisper, ClanLocalization.Text("chat_channel_whisper"), 86f);
			((Component)_whisperButton).gameObject.SetActive(ClanPlugin.ShowWhisperChatButton.Value.IsOn());
			LayoutRebuilder.ForceRebuildLayoutImmediate(val);
		}

		private static RectTransform BuildRailButtonDock(Transform parent, string name, string label, Action onClick, out Button button)
		{
			//IL_0046: 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_0070: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			GameObject val = ClanUiFactory.CreateObject(name, parent, typeof(Image), typeof(VerticalLayoutGroup), typeof(DockPointerFocusKeeper));
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.sizeDelta = new Vector2(66f, 40f);
			((Graphic)val.GetComponent<Image>()).color = DockBackgroundColor;
			VerticalLayoutGroup component2 = val.GetComponent<VerticalLayoutGroup>();
			((LayoutGroup)component2).padding = new RectOffset(3, 3, 5, 5);
			((HorizontalOrVerticalLayoutGroup)component2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = false;
			button = AddRailButton(val.transform, label, onClick);
			LayoutRebuilder.ForceRebuildLayoutImmediate(component);
			return component;
		}

		private static void BuildCommandDock(Transform parent)
		{
			//IL_005f: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			GameObject obj = ClanUiFactory.CreateObject("ClanDockCommands", parent, typeof(Image), typeof(HorizontalLayoutGroup), typeof(ContentSizeFitter), typeof(DockPointerFocusKeeper));
			_commandDockRect = obj.GetComponent<RectTransform>();
			_commandDockRect.anchorMin = new Vector2(0.5f, 0.5f);
			_commandDockRect.anchorMax = new Vector2(0.5f, 0.5f);
			_commandDockRect.sizeDelta = new Vector2(176f, 40f);
			((Graphic)obj.GetComponent<Image>()).color = DockBackgroundColor;
			HorizontalLayoutGroup component = obj.GetComponent<HorizontalLayoutGroup>();
			((LayoutGroup)component).padding = new RectOffset(5, 5, 5, 5);
			((HorizontalOrVerticalLayoutGroup)component).spacing = 4f;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			ContentSizeFitter component2 = obj.GetComponent<ContentSizeFitter>();
			component2.horizontalFit = (FitMode)2;
			component2.verticalFit = (FitMode)0;
			_resetSpawnButton = AddCommandButton(obj.transform, ClanLocalization.Text("chat_command_reset_spawn"), CommandAction.ResetSpawn, 104f);
			_dieButton = AddCommandButton(obj.transform, ClanLocalization.Text("chat_command_die"), CommandAction.Die, 54f);
			RefreshConfiguredCommandVisibility();
			RefreshCommandButtonStates();
			if (obj.activeSelf)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(_commandDockRect);
			}
		}

		private static void PlaceChannelDock(RectTransform channelRect, RectTransform rootRect, RectTransform inputRect, bool railPositioned, bool railOnLeft, float railHorizontalPoint)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: 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_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			Rect chatVisualScreenBounds = GetChatVisualScreenBounds(_chatPanelRect ?? inputRect);
			Rect screenBounds = GetScreenBounds(channelRect);
			Rect safeArea = GetSafeArea();
			float width = ((Rect)(ref screenBounds)).width;
			float height = ((Rect)(ref screenBounds)).height;
			bool flag = ((Rect)(ref chatVisualScreenBounds)).yMin - ((Rect)(ref safeArea)).yMin >= height + 4f;
			float num = Mathf.Max(((Rect)(ref safeArea)).xMin, ((Rect)(ref safeArea)).xMax - width);
			RectTransform chatViewDockRect = _chatViewDockRect;
			Rect val = (Rect)(((Object)(object)chatViewDockRect == (Object)null) ? default(Rect) : GetScreenBounds(chatViewDockRect));
			float num2 = ((railPositioned && (Object)(object)chatViewDockRect != (Object)null) ? (railHorizontalPoint + (railOnLeft ? 4f : (((Rect)(ref val)).width + 4f))) : ((Rect)(ref chatVisualScreenBounds)).xMin);
			num2 = Mathf.Clamp(num2, ((Rect)(ref safeArea)).xMin, num);
			float num3 = (flag ? Mathf.Clamp(((Rect)(ref chatVisualScreenBounds)).yMin - 4f, ((Rect)(ref safeArea)).yMin + height, ((Rect)(ref safeArea)).yMax) : Mathf.Clamp(((Rect)(ref chatVisualScreenBounds)).yMin + 4f, ((Rect)(ref safeArea)).yMin, Mathf.Max(((Rect)(ref safeArea)).yMin, ((Rect)(ref safeArea)).yMax - height)));
			channelRect.pivot = new Vector2(0f, flag ? 1f : 0f);
			PlaceAtScreenPoint(channelRect, rootRect, new Vector2(num2, num3));
			if (!((Object)(object)chatViewDockRect == (Object)null))
			{
				bool flag2 = (railPositioned ? railOnLeft : (((Rect)(ref chatVisualScreenBounds)).xMin - ((Rect)(ref safeArea)).xMin >= ((Rect)(ref val)).width + 4f));
				float num4 = (railPositioned ? railHorizontalPoint : (flag2 ? Mathf.Clamp(((Rect)(ref chatVisualScreenBounds)).xMin - 4f, ((Rect)(ref safeArea)).xMin + ((Rect)(ref val)).width, ((Rect)(ref safeArea)).xMax) : Mathf.Clamp(((Rect)(ref chatVisualScreenBounds)).xMax + 4f, ((Rect)(ref safeArea)).xMin, Mathf.Max(((Rect)(ref safeArea)).xMin, ((Rect)(ref safeArea)).xMax - ((Rect)(ref val)).width))));
				chatViewDockRect.pivot = new Vector2(flag2 ? 1f : 0f, flag ? 1f : 0f);
				PlaceAtScreenPoint(chatViewDockRect, rootRect, new Vector2(num4, num3));
			}
		}

		private static void PlaceCommandDock(RectTransform commandRect, RectTransform rootRect, RectTransform inputRect)
		{
			//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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00f8: 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)
			if (((Component)commandRect).gameObject.activeSelf)
			{
				Rect chatVisualScreenBounds = GetChatVisualScreenBounds(_chatPanelRect ?? inputRect);
				Rect screenBounds = GetScreenBounds(commandRect);
				Rect safeArea = GetSafeArea();
				float width = ((Rect)(ref screenBounds)).width;
				float height = ((Rect)(ref screenBounds)).height;
				bool flag = ((Rect)(ref chatVisualScreenBounds)).yMin - ((Rect)(ref safeArea)).yMin >= height + 4f;
				float num = Mathf.Min(((Rect)(ref safeArea)).xMax, ((Rect)(ref safeArea)).xMin + width);
				float num2 = Mathf.Clamp(((Rect)(ref chatVisualScreenBounds)).xMax, num, ((Rect)(ref safeArea)).xMax);
				float num3 = (flag ? Mathf.Clamp(((Rect)(ref chatVisualScreenBounds)).yMin - 4f, ((Rect)(ref safeArea)).yMin + height, ((Rect)(ref safeArea)).yMax) : Mathf.Clamp(((Rect)(ref chatVisualScreenBounds)).yMin + 4f, ((Rect)(ref safeArea)).yMin, Mathf.Max(((Rect)(ref safeArea)).yMin, ((Rect)(ref safeArea)).yMax - height)));
				commandRect.pivot = new Vector2(1f, flag ? 1f : 0f);
				PlaceAtScreenPoint(commandRect, rootRect, new Vector2(num2, num3));
			}
		}

		private static bool PlaceLeftRailStack(RectTransform rootRect, RectTransform inputRect, Rect inputBounds, out bool placeLeft, out float horizontalPoint)
		{
			//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_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_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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: 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_02b2: Unknown result type (might be due to invalid IL or missing references)
			placeLeft = true;
			horizontalPoint = 0f;
			RectTransform emojiButtonDockRect = _emojiButtonDockRect;
			RectTransform clanButtonDockRect = _clanButtonDockRect;
			RectTransform emojiTrayRect = _emojiTrayRect;
			RectTransform resizeHandleRect = _resizeHandleRect;
			if ((Object)(object)emojiButtonDockRect == (Object)null || (Object)(object)clanButtonDockRect == (Object)null || (Object)(object)emojiTrayRect == (Object)null || (Object)(object)resizeHandleRect == (Object)null)
			{
				return false;
			}
			bool flag = (Object)(object)_chatPanelRect != (Object)null && _canResizeChatPanel;
			((Component)resizeHandleRect).gameObject.SetActive(flag);
			SetEmojiTrayVisibleRows(5);
			Rect safeArea = GetSafeArea();
			Rect screenBounds = GetScreenBounds(emojiButtonDockRect);
			Rect screenBounds2 = GetScreenBounds(clanButtonDockRect);
			Rect screenBounds3 = GetScreenBounds(emojiTrayRect);
			Rect val;
			Rect val2;
			if (!flag)
			{
				val = default(Rect);
				val2 = val;
			}
			else
			{
				val2 = GetScreenBounds(resizeHandleRect);
			}
			Rect val3 = val2;
			float num = ((Rect)(ref inputBounds)).yMin;
			if ((Object)(object)_chatViewDockRect != (Object)null && (Object)(object)_channelDockRect != (Object)null)
			{
				Rect chatVisualScreenBounds = GetChatVisualScreenBounds(_chatPanelRect ?? inputRect);
				Rect val4 = (IsUsableChatPlacementBounds(chatVisualScreenBounds, safeArea) ? chatVisualScreenBounds : inputBounds);
				Rect screenBounds4 = GetScreenBounds(_channelDockRect);
				Rect screenBounds5 = GetScreenBounds(_chatViewDockRect);
				if (!(((Rect)(ref val4)).yMin - ((Rect)(ref safeArea)).yMin >= ((Rect)(ref screenBounds4)).height + 4f))
				{
					float num2 = Mathf.Max(((Rect)(ref screenBounds4)).height, ((Rect)(ref screenBounds5)).height);
					float num3 = Mathf.Clamp(((Rect)(ref val4)).yMin + 4f, ((Rect)(ref safeArea)).yMin, Mathf.Max(((Rect)(ref safeArea)).yMin, ((Rect)(ref safeArea)).yMax - num2));
					num = Mathf.Max(num, num3 + num2 + 4f);
				}
			}
			float num4 = ((Rect)(ref screenBounds)).height + ((Rect)(ref screenBounds2)).height + 8f;
			if (flag)
			{
				num4 += ((Rect)(ref val3)).height + 4f;
			}
			int num5 = 5;
			float num6 = Mathf.Max(0f, ((Rect)(ref safeArea)).yMax - Mathf.Max(((Rect)(ref safeArea)).yMin, num));
			while (num5 > 1 && num4 + ((Rect)(ref screenBounds3)).height > num6)
			{
				num5--;
				SetEmojiTrayVisibleRows(num5);
				screenBounds3 = GetScreenBounds(emojiTrayRect);
			}
			RefreshEmojiScrollBehavior();
			float num7 = num4 + ((Rect)(ref screenBounds3)).height;
			float num8 = Mathf.Max(Mathf.Max(((Rect)(ref screenBounds)).width, ((Rect)(ref screenBounds2)).width), ((Rect)(ref screenBounds3)).width);
			if (flag)
			{
				num8 = Mathf.Max(num8, ((Rect)(ref val3)).width);
			}
			placeLeft = ((Rect)(ref inputBounds)).xMin - ((Rect)(ref safeArea)).xMin >= num8 + 4f;
			float num9 = num8;
			if (!placeLeft && (Object)(object)_chatViewDockRect != (Object)null && (Object)(object)_channelDockRect != (Object)null)
			{
				float num10 = num9;
				val = GetScreenBounds(_chatViewDockRect);
				float num11 = ((Rect)(ref val)).width + 4f;
				val = GetScreenBounds(_channelDockRect);
				num9 = Mathf.Max(num10, num11 + ((Rect)(ref val)).width);
			}
			horizontalPoint = (placeLeft ? Mathf.Clamp(((Rect)(ref inputBounds)).xMin - 4f, ((Rect)(ref safeArea)).xMin + num8, ((Rect)(ref safeArea)).xMax) : Mathf.Clamp(((Rect)(ref inputBounds)).xMin + 4f, ((Rect)(ref safeArea)).xMin, Mathf.Max(((Rect)(ref safeArea)).xMin, ((Rect)(ref safeArea)).xMax - num9)));
			float num12 = Mathf.Clamp(num, ((Rect)(ref safeArea)).yMin, Mathf.Max(((Rect)(ref safeArea)).yMin, ((Rect)(ref safeArea)).yMax - num7));
			PlaceLeftRailElement(emojiButtonDockRect, rootRect, placeLeft, horizontalPoint, num12);
			num12 += ((Rect)(ref screenBounds)).height + 4f;
			PlaceLeftRailElement(emojiTrayRect, rootRect, placeLeft, horizontalPoint, num12);
			num12 += ((Rect)(ref screenBounds3)).height + 4f;
			PlaceLeftRailElement(clanButtonDockRect, rootRect, placeLeft, horizontalPoint, num12);
			if (flag)
			{
				num12 += ((Rect)(ref screenBounds2)).height + 4f;
				PlaceLeftRailElement(resizeHandleRect, rootRect, placeLeft, horizontalPoint, num12);
			}
			return true;
		}

		private static void PlaceLeftRailElement(RectTransform rect, RectTransform rootRect, bool placeLeft, float horizontalPoint, float bottom)
		{
			//IL_0015: 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)
			rect.pivot = new Vector2(placeLeft ? 1f : 0f, 0f);
			PlaceAtScreenPoint(rect, rootRect, new Vector2(horizontalPoint, bottom));
		}

		private static void PlaceStandaloneClanNotification(RectTransform rootRect)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			RectTransform clanButtonDockRect = _clanButtonDockRect;
			if (!((Object)(object)clanButtonDockRect == (Object)null) && !TryPlaceCachedClanDockNotification(clanButtonDockRect, rootRect))
			{
				ApplyClanDockScale(GetConfiguredChatScale());
				clanButtonDockRect.pivot = new Vector2(0.5f, 0.5f);
				Rect safeArea = GetSafeArea();
				PlaceAtScreenPoint(clanButtonDockRect, rootRect, ((Rect)(ref safeArea)).center);
			}
		}

		private static bool TryPlaceCachedClanDockNotification(RectTransform clanDock, RectTransform rootRect)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			Rect safeArea = GetSafeArea();
			TMP_InputField inputField = GetInputField();
			int num = (((Object)(object)Chat.instance != (Object)null) ? ((Object)Chat.instance).GetInstanceID() : 0);
			int num2 = (((Object)(object)inputField != (Object)null) ? ((Object)inputField).GetInstanceID() : 0);
			bool flag = _clanDockCacheScreenWidth == Screen.width && _clanDockCacheScreenHeight == Screen.height && Approximately(_clanDockCacheSafeArea, safeArea) && Mathf.Approximately(_clanDockCacheConfiguredScale, GetConfiguredChatScale()) && _clanDockCacheChatId == num && _clanDockCacheInputId == num2;
			if (!_hasCachedClanDockPlacement)
			{
				return false;
			}
			if (!flag || !IsFinite(_cachedClanDockScreenPoint.x) || !IsFinite(_cachedClanDockScreenPoint.y) || !IsFinitePositive(_cachedClanDockLocalScale.x) || !IsFinitePositive(_cachedClanDockLocalScale.y) || !IsFinitePositive(_cachedClanDockLocalScale.z))
			{
				ResetClanDockPlacementCache();
				return false;
			}
			SetDockScale(clanDock, _cachedClanDockLocalScale);
			clanDock.pivot = _cachedClanDockPivot;
			PlaceAtScreenPoint(clanDock, rootRect, _cachedClanDockScreenPoint);
			return true;
		}

		private static void CacheClanDockPlacement()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			RectTransform clanButtonDockRect = _clanButtonDockRect;
			TMP_InputField inputField = GetInputField();
			if (!((Object)(object)clanButtonDockRect == (Object)null) && !((Object)(object)inputField == (Object)null) && !((Object)(object)Chat.instance == (Object)null))
			{
				Vector2 val = RectTransformUtility.WorldToScreenPoint((Camera)null, ((Transform)clanButtonDockRect).position);
				if (IsFinite(val.x) && IsFinite(val.y))
				{
					_hasCachedClanDockPlacement = true;
					_cachedClanDockScreenPoint = val;
					_cachedClanDockPivot = clanButtonDockRect.pivot;
					_cachedClanDockLocalScale = ((Transform)clanButtonDockRect).localScale;
					_clanDockCacheScreenWidth = Screen.width;
					_clanDockCacheScreenHeight = Screen.height;
					_clanDockCacheSafeArea = GetSafeArea();
					_clanDockCacheConfiguredScale = GetConfiguredChatScale();
					_clanDockCacheChatId = ((Object)Chat.instance).GetInstanceID();
					_clanDockCacheInputId = ((Object)inputField).GetInstanceID();
				}
			}
		}

		private static void ResetClanDockPlacementCache()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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)
			_hasCachedClanDockPlacement = false;
			_cachedClanDockScreenPoint = default(Vector2);
			_cachedClanDockPivot = default(Vector2);
			_cachedClanDockLocalScale = Vector3.one;
			_clanDockCacheScreenWidth = 0;
			_clanDockCacheScreenHeight = 0;
			_clanDockCacheSafeArea = default(Rect);
			_clanDockCacheConfiguredScale = 0f;
			_clanDockCacheChatId = 0;
			_clanDockCacheInputId = 0;
		}

		private static void SetEmojiTrayVisibleRows(int rowCount)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_emojiTrayRect == (Object)null))
			{
				int num = Mathf.Clamp(rowCount, 1, 5);
				float num2 = 12f + 52f * (float)num + 4f * (float)(num - 1);
				_emojiTrayRect.sizeDelta = new Vector2(288f, num2);
			}
		}

		private static void PlaceAtScreenPoint(RectTransform rect, RectTransform rootRect, Vector2 screenPoint)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Vector2 anchoredPosition = default(Vector2);
			RectTransformUtility.ScreenPointToLocalPointInRectangle(rootRect, screenPoint, (Camera)null, ref anchoredPosition);
			rect.anchoredPosition = anchoredPosition;
		}

		private static void BuildEmojiTray(Transform parent)
		{
			//IL_005b: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: 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_0142: 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_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: 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_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
			_emojiTray = ClanUiFactory.CreateObject("ClanEmojiTray", parent, typeof(Image), typeof(ScrollRect), typeof(DockPointerFocusKeeper));
			_emojiTrayRect = _emojiTray.GetComponent<RectTransform>();
			_emojiTrayRect.anchorMin = new Vector2(0.5f, 0.5f);
			_emojiTrayRect.anchorMax = new Vector2(0.5f, 0.5f);
			_emojiTrayRect.sizeDelta = new Vector2(288f, 288f);
			((Graphic)_emojiTray.GetComponent<Image>()).color = DockBackgroundColor;
			GameObject val = ClanUiFactory.CreateObject("Viewport", _emojiTray.transform, typeof(Image), typeof(Mask));
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = new Vector2(6f, 6f);
			component.offsetMax = new Vector2(-6f, -6f);
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0.01f);
			((Graphic)component2).raycastTarget = false;
			val.GetComponent<Mask>().showMaskGraphic = false;
			GameObject obj = ClanUiFactory.CreateObject("Content", val.transform, typeof(GridLayoutGroup), typeof(ContentSizeFitter));
			_emojiContent = obj.GetComponent<RectTransform>();
			_emojiContent.anchorMin = new Vector2(0f, 1f);
			_emojiContent.anchorMax = new Vector2(1f, 1f);
			_emojiContent.pivot = new Vector2(0.5f, 1f);
			_emojiContent.anchoredPosition = Vector2.zero;
			_emojiContent.sizeDelta = Vector2.zero;
			GridLayoutGroup component3 = obj.GetComponent<GridLayoutGroup>();
			component3.cellSize = new Vector2(52f, 52f);
			component3.spacing = new Vector2(4f, 4f);
			component3.startCorner = (Corner)0;
			component3.startAxis = (Axis)0;
			((LayoutGroup)component3).childAlignment = (TextAnchor)0;
			component3.constraint = (Constraint)1;
			component3.constraintCount = 5;
			ContentSizeFitter component4 = obj.GetComponent<ContentSizeFitter>();
			component4.horizontalFit = (FitMode)0;
			component4.verticalFit = (FitMode)2;
			ScrollRect component5 = _emojiTray.GetComponent<ScrollRect>();
			component5.content = _emojiContent;
			component5.viewport = component;
			component5.horizontal = false;
			component5.vertical = true;
			ClanUiFactory.ConfigureVerticalScroll(component5, hasOverflow: true);
			GameObject val2 = ClanUiFactory.CreateObject("Scrollbar", _emojiTray.transform, typeof(Image), typeof(Scrollbar));
			RectTransform component6 = val2.GetComponent<RectTransform>();
			component6.anchorMin = new Vector2(0f, 0f);
			component6.anchorMax = new Vector2(0f, 1f);
			component6.offsetMin = new Vector2(0f, 6f);
			component6.offsetMax = new Vector2(2f, -6f);
			((Graphic)val2.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.42f);
			GameObject obj2 = ClanUiFactory.CreateObject("Handle", val2.transform, typeof(Image));
			RectTransform component7 = obj2.GetComponent<RectTransform>();
			component7.anchorMin = Vector2.zero;
			component7.anchorMax = Vector2.one;
			component7.offsetMin = Vector2.zero;
			component7.offsetMax = Vector2.zero;
			Image component8 = obj2.GetComponent<Image>();
			((Graphic)component8).color = new Color(1f, 0.63f, 0.24f, 0.96f);
			Scrollbar component9 = val2.GetComponent<Scrollbar>();
			component9.handleRect = component7;
			((Selectable)component9).targetGraphic = (Graphic)(object)component8;
			component9.direction = (Direction)2;
			((Selectable)component9).transition = (Transition)0;
			component9.value = 1f;
			component5.verticalScrollbar = component9;
			component5.verticalScrollbarVisibility = (ScrollbarVisibility)0;
			component5.verticalScrollbarSpacing = 0f;
			RebuildEmojiTrayContent();
			_emojiTray.SetActive(_emojiTrayOpen && ClanEmoji.IsReady);
		}

		private static void RebuildEmojiTrayContent()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_emojiContent == (Object)null)
			{
				return;
			}
			ClanUiFactory.ClearChildren((Transform)(object)_emojiContent);
			for (int i = 0; i < ClanEmoji.EmojiCount; i++)
			{
				int emojiIndex = i;
				Button val = CreateButton((Transform)(object)_emojiContent, "", delegate
				{
					AppendEmojiToken(emojiIndex);
				}, 52f);
				((Object)((Component)val).gameObject).name = $"EmojiButton{emojiIndex}";
				GameObject obj = ClanUiFactory.CreateObject("Icon", ((Component)val).transform, typeof(Image));
				Image component = obj.GetComponent<Image>();
				component.sprite = ClanEmoji.GetPickerSprite(emojiIndex);
				((Graphic)component).color = Color.white;
				component.preserveAspect = true;
				((Graphic)component).raycastTarget = false;
				RectTransform component2 = obj.GetComponent<RectTransform>();
				component2.anchorMin = new Vector2(0.5f, 0.5f);
				component2.anchorMax = new Vector2(0.5f, 0.5f);
				component2.pivot = new Vector2(0.5f, 0.5f);
				component2.anchoredPosition = Vector2.zero;
				component2.sizeDelta = new Vector2(44f, 44f);
				if (ClanEmoji.IsGifEmoji(emojiIndex))
				{
					GameObject obj2 = ClanUiFactory.CreateObject("GifBadge", ((Component)val).transform, typeof(Image));
					Image component3 = obj2.GetComponent<Image>();
					((Graphic)component3).color = new Color(0.04f, 0.04f, 0.04f, 0.82f);
					((Graphic)component3).raycastTarget = false;
					RectTransform component4 = obj2.GetComponent<RectTransform>();
					component4.anchorMin = Vector2.one;
					component4.anchorMax = Vector2.one;
					component4.pivot = Vector2.one;
					component4.anchoredPosition = new Vector2(-2f, -2f);
					component4.sizeDelta = new Vector2(23f, 13f);
					Text obj3 = CreateLabel(obj2.transform, ClanLocalization.Text("chat_emoji_gif_badge"), 9, (TextAnchor)4);
					((Graphic)obj3).raycastTarget = false;
					RectTransform component5 = ((Component)obj3).GetComponent<RectTransform>();
					component5.anchorMin = Vector2.zero;
					component5.anchorMax = Vector2.one;
					component5.offsetMin = Vector2.zero;
					component5.offsetMax = Vector2.zero;
				}
			}
			RefreshEmojiScrollBehavior();
		}

		private static void RefreshEmojiScrollBehavior()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_emojiTray == (Object)null) && !((Object)(object)_emojiTrayRect == (Object)null) && !((Object)(object)_emojiContent == (Object)null))
			{
				ScrollRect component = _emojiTray.GetComponent<ScrollRect>();
				if (!((Object)(object)component == (Object)null))
				{
					int num = (ClanEmoji.EmojiCount + 5 - 1) / 5;
					float num2 = ((num == 0) ? 0f : ((float)num * 52f + (float)(num - 1) * 4f));
					float num3 = Mathf.Max(0f, _emojiTrayRect.sizeDelta.y - 12f);
					bool hasOverflow = num2 > num3 + 0.5f;
					ClanUiFactory.ConfigureVerticalScroll(component, hasOverflow, _emojiContent);
				}
			}
		}

		private static Button AddRailButton(Transform parent, string label, Action onClick)
		{
			Button obj = CreateButton(parent, label, onClick, 60f);
			AddPreferredHeight(((Component)obj).gameObject, 30f);
			return obj;
		}

		private static bool ShouldToggleClanPanelFromShortcut(Chat chat, TMP_InputField input)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (!ClanPlugin.ClanPanelShortcut.Value.IsKeyDown())
			{
				return false;
			}
			if (!input.isFocused && !HasPendingChatRefocus(chat) && !ClanPanelController.OwnsFocusedTextInput)
			{
				return !IsBlockingModalVisible();
			}
			return false;
		}

		private static bool ShouldOpenEmojiTrayFromShortcut(Chat chat, TMP_InputField input)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (!ClanPlugin.EmojiPanelShortcut.Value.IsKeyDown())
			{
				return false;
			}
			if (!input.isFocused && !HasPendingChatRefocus(chat) && !ClanPanelController.OwnsFocusedTextInput)
			{
				return !IsBlockingModalVisible();
			}
			return false;
		}

		private static bool TryHandleClanPanelCancel()
		{
			if (!ClanPanelController.IsOpen || (!ZInput.GetKeyDown((KeyCode)27, true) && !ZInput.GetButtonDown("JoyButtonB")) || IsBlockingModalVisible())
			{
				return false;
			}
			if (!ClanPanelController.HandleCancelInput())
			{
				return false;
			}
			_clanPanelCancelFrame = Time.frameCount;
			CancelPendingChatRefocus();
			return true;
		}

		private static void ToggleClanPanelFromDock()
		{
			ToggleClanPanel(keepChatVisibleWhenOpening: true);
		}

		private static void ToggleClanPanel(bool keepChatVisibleWhenOpening)
		{
			bool num = !ClanPanelController.IsOpen;
			CloseEmojiTray();
			if (num)
			{
				_keepChatVisibleForClanPanel = keepChatVisibleWhenOpening;
				ClanPanelController.Toggle();
				if (!ClanPanelController.IsOpen)
				{
					_keepChatVisibleForClanPanel = false;
					return;
				}
				ClanRpc.RequestSnapshot();
				ClanRpc.RequestDirectory();
			}
			else
			{
				ClanPanelController.Close();
			}
		}

		private static void ToggleEmojiTray()
		{
			if (!ClanEmoji.IsReady)
			{
				ClanRpc.NotifyStatus(ClanLocalization.Text("chat_emoji_unavailable"));
				return;
			}
			_emojiTrayOpen = !_emojiTrayOpen;
			ClanPanelController.Close();
			if ((Object)(object)_emojiTray != (Object)null)
			{
				_emojiTray.SetActive(_emojiTrayOpen);
			}
			RefreshButtonStates();
			RefreshEmojiPanelTooltip();
		}

		private static void OpenEmojiTrayFromShortcut(Chat chat, TMP_InputField input)
		{
			if (!_emojiTrayOpen)
			{
				ToggleEmojiTray();
			}
			if (_emojiTrayOpen)
			{
				EnsureChatVisible(chat, input);
				EventSystem current = EventSystem.current;
				if (current != null)
				{
					current.SetSelectedGameObject((GameObject)null);
				}
				_emojiShortcutFocusFrame = Time.frameCount + 1;
			}
		}

		private static void ApplyPendingEmojiShortcutFocus(TMP_InputField input)
		{
			if (_emojiShortcutFocusFrame >= 0 && Time.frameCount >= _emojiShortcutFocusFrame)
			{
				_emojiShortcutFocusFrame = -1;
				Chat instance = Chat.instance;
				if (_emojiTrayOpen && !((Object)(object)instance == (Object)null) && !IsBlockingModalVisible())
				{
					EnsureChatVisible(instance, input);
					FocusChatInputAtEnd(input);
				}
			}
		}

		private static void BuildResizeHandle(Transform parent)
		{
			//IL_0052: 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_0084: 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_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_00c5: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_012c: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = ClanUiFactory.CreateObject("ClanChatResizeHandle", parent, typeof(Image), typeof(Button), typeof(ChatScaleDragHandle));
			_resizeHandleRect = obj.GetComponent<RectTransform>();
			_resizeHandleRect.anchorMin = new Vector2(0.5f, 0.5f);
			_resizeHandleRect.anchorMax = new Vector2(0.5f, 0.5f);
			_resizeHandleRect.sizeDelta = new Vector2(42f, 42f);
			Image component = obj.GetComponent<Image>();
			((Graphic)component).color = Color.white;
			((Graphic)component).raycastTarget = true;
			Button component2 = obj.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			Navigation navigation = ((Selectable)component2).navigation;
			((Navigation)(ref navigation)).mode = (Mode)0;
			((Selectable)component2).navigation = navigation;
			Text obj2 = CreateLabel(obj.transform, "", 12, (TextAnchor)4);
			((Graphic)obj2).raycastTarget = false;
			RectTransform component3 = ((Component)obj2).GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.offsetMin = Vector2.zero;
			component3.offsetMax = Vector2.zero;
			obj.AddComponent<LayoutElement>().ignoreLayout = true;
			TryApplyButtonStyle(component2);
			SetButtonColor(component2, ButtonColor, Color.white);
			ClanUiFeedback.ApplyIcon(component2, ClanActionIcon.Resize, string.Empty, 28f);
		}

		private static void RefreshDockPositions(TMP_InputField input)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_rootRect == (Object)null))
			{
				RectTransform component = ((Component)input).GetComponent<RectTransform>();
				RefreshChatPanelTarget(component);
				float dockScale;
				Rect inputBounds = ResolveChatPlacementBounds(component, out dockScale);
				ApplyClanDockScale(dockScale);
				bool placeLeft;
				float horizontalPoint;
				bool flag = PlaceLeftRailStack(_rootRect, component, inputBounds, out placeLeft, out horizontalPoint);
				if ((Object)(object)_channelDockRect != (Object)null)
				{
					PlaceChannelDock(_channelDockRect, _rootRect, component, flag, placeLeft, horizontalPoint);
				}
				if ((Object)(object)_commandDockRect != (Object)null)
				{
					PlaceCommandDock(_commandDockRect, _rootRect, component);
				}
				if (flag && IsChatInputOpen(input))
				{
					CacheClanDockPlacement();
				}
				ClanPanelController.RefreshPosition(_rootRect);
			}
		}

		private static void RefreshChatPanelTarget(RectTransform inputRect)
		{
			RectTransform val = ResolveChatPanelRect(inputRect);
			bool flag = CanResizeDeclaredChatWindow(inputRect, val);
			if ((Object)(object)_chatPanelRect != (Object)(object)val || _canResizeChatPanel != flag)
			{
				_chatPanelRect = val;
				_canResizeChatPanel = flag;
			}
			RefreshChatScaleTarget(val, flag);
		}

		private static Rect ResolveChatPlacementBounds(RectTransform inputRect, out float dockScale)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			Rect safeArea = GetSafeArea();
			Canvas componentInParent = ((Component)inputRect).GetComponentInParent<Canvas>(true);
			int canvasId = (((Object)(object)componentInParent != (Object)null) ? ((Object)componentInParent).GetInstanceID() : 0);
			float num = (((Object)(object)componentInParent != (Object)null && IsFinitePositive(componentInParent.scaleFactor)) ? componentInParent.scaleFactor : 1f);
			float configuredChatScale = GetConfiguredChatScale();
			EnsureChatPlacementCacheEnvironment(inputRect, canvasId, num, safeArea, configuredChatScale);
			Rect screenBounds = GetScreenBounds(inputRect);
			if (((Component)inputRect).gameObject.activeInHierarchy && IsUsableChatPlacementBounds(screenBounds, safeArea))
			{
				dockScale = ((_canResizeChatPanel && (Object)(object)_chatScaleTarget == (Object)(object)_chatPanelRect) ? _chatScaleFactor : 1f);
				_hasCachedChatInputBounds = true;
				_cachedChatInputBounds = screenBounds;
				_cachedChatDockScale = dockScale;
				return screenBounds;
			}
			if (_hasCachedChatInputBounds && IsUsableChatPlacementBounds(_cachedChatInputBounds, safeArea))
			{
				dockScale = _cachedChatDockScale;
				return _cachedChatInputBounds;
			}
			return BuildFallbackChatInputBounds(inputRect, num, screenBounds, safeArea, configuredChatScale, out dockScale);
		}

		private static void EnsureChatPlacementCacheEnvironment(RectTransform inputRect, int canvasId, float canvasScaleFactor, Rect safeArea, float configuredScale)
		{
			//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_0066: 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)
			if (_chatPlacementCacheScreenWidth != Screen.width || _chatPlacementCacheScreenHeight != Screen.height || !Approximately(_chatPlacementCacheSafeArea, safeArea) || !Mathf.Approximately(_chatPlacementCacheConfiguredScale, configuredScale) || !Mathf.Approximately(_chatPlacementCacheCanvasScaleFactor, canvasScaleFactor) || _chatPlacementCacheCanvasId != canvasId || _chatPlacementCacheInputId != ((Object)inputRect).GetInstanceID())
			{
				_hasCachedChatInputBounds = false;
				_cachedChatInputBounds = default(Rect);
				_cachedChatDockScale = 1f;
				_chatPlacementCacheScreenWidth = Screen.width;
				_chatPlacementCacheScreenHeight = Screen.height;
				_chatPlacementCacheSafeArea = safeArea;
				_chatPlacementCacheConfiguredScale = configuredScale;
				_chatPlacementCacheCanvasScaleFactor = canvasScaleFactor;
				_chatPlacementCacheCanvasId = canvasId;
				_chatPlacementCacheInputId = ((Object)inputRect).GetInstanceID();
			}
		}

		private static Rect BuildFallbackChatInputBounds(RectTransform inputRect, float canvasScale, Rect measuredBounds, Rect safeArea, float configuredScale, out float dockScale)
		{
			//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)
			//IL_000f: 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)
			Rect rect = inputRect.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			float num = Mathf.Abs(size.x);
			float num2 = Mathf.Abs(size.y);
			if (!IsFinitePositive(num) || num <= 1f)
			{
				num = 500f;
			}
			if (!IsFinitePositive(num2) || num2 <= 1f)
			{
				num2 = 36f;
			}
			float num3 = num * canvasScale;
			float num4 = num2 * canvasScale;
			float num5 = ((IsFinite(((Rect)(ref measuredBounds)).yMin) && ((Rect)(ref measuredBounds)).yMin >= ((Rect)(ref safeArea)).yMin && ((Rect)(ref measuredBounds)).yMin < ((Rect)(ref safeArea)).yMax) ? ((Rect)(ref measuredBounds)).yMin : (((Rect)(ref safeArea)).yMin + 4f));
			float num6 = Mathf.Max(1f, ((Rect)(ref safeArea)).width - 8f);
			float num7 = Mathf.Max(1f, ((Rect)(ref safeArea)).yMax - num5 - 4f);
			float num8 = Mathf.Min(num6 / num3, num7 / num4);
			dockScale = (_canResizeChatPanel ? Mathf.Clamp(Mathf.Min(configuredScale, num8), 1f, 2f) : 1f);
			float num9 = Mathf.Min(num6, num3 * dockScale);
			float num10 = Mathf.Min(num7, num4 * dockScale);
			num5 = Mathf.Clamp(num5, ((Rect)(ref safeArea)).yMin, Mathf.Max(((Rect)(ref safeArea)).yMin, ((Rect)(ref safeArea)).yMax - num10));
			return new Rect(((Rect)(ref safeArea)).xMax - 4f - num9, num5, num9, num10);
		}

		private static bool IsUsableChatPlacementBounds(Rect bounds, Rect safeArea)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!IsFiniteNonTrivialRect(bounds))
			{
				return false;
			}
			float num = Mathf.Min(((Rect)(ref bounds)).xMax, ((Rect)(ref safeArea)).xMax) - Mathf.Max(((Rect)(ref bounds)).xMin, ((Rect)(ref safeArea)).xMin);
			float num2 = Mathf.Min(((Rect)(ref bounds)).yMax, ((Rect)(ref safeArea)).yMax) - Mathf.Max(((Rect)(ref bounds)).yMin, ((Rect)(ref safeArea)).yMin);
			if (num > 1f)
			{
				return num2 > 1f;
			}
			return false;
		}

		private static bool HasUsableChatVisualGeometry(RectTransform target)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return IsUsableChatPlacementBounds(GetChatVisualScreenBounds(target), GetSafeArea());
		}

		private static float GetConfiguredChatScale()
		{
			float value = ClanPlugin.ClanChatWindowScale.Value;
			if (!IsFinite(value))
			{
				return 1f;
			}
			return Mathf.Clamp(value, 1f, 2f);
		}

		private static void ResetChatPlacementCache()
		{
			//IL_000b: 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)
			_hasCachedChatInputBounds = false;
			_cachedChatInputBounds = default(Rect);
			_cachedChatDockScale = 1f;
			_chatPlacementCacheScreenWidth = 0;
			_chatPlacementCacheScreenHeight = 0;
			_chatPlacementCacheSafeArea = default(Rect);
			_chatPlacementCacheConfiguredScale = 0f;
			_chatPlacementCacheCanvasScaleFactor = 0f;
			_chatPlacementCacheCanvasId = 0;
			_chatPlacementCacheInputId = 0;
			ResetClanDockPlacementCache();
		}

		private static bool Approximately(Rect left, Rect right)
		{
			if (Mathf.Approximately(((Rect)(ref left)).x, ((Rect)(ref right)).x) && Mathf.Approximately(((Rect)(ref left)).y, ((Rect)(ref right)).y) && Mathf.Approximately(((Rect)(ref left)).width, ((Rect)(ref right)).width))
			{
				return Mathf.Approximately(((Rect)(ref left)).height, ((Rect)(ref right)).height);
			}
			return false;
		}

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

		private static bool IsFinitePositive(float value)
		{
			if (IsFinite(value))
			{
				return value > 0f;
			}
			return false;
		}

		private static Rect GetChatVisualScreenBounds(RectTransform target)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			float left = float.PositiveInfinity;
			float top = float.NegativeInfinity;
			float right = float.NegativeInfinity;
			float bottom = float.PositiveInfinity;
			bool found = false;
			TextMeshProUGUI obj = (((Object)(object)Chat.instance != (Object)null) ? ((Terminal)Chat.instance).m_output : null);
			IncludeChatVisualRect((obj != null) ? ((Component)obj).GetComponent<RectTransform>() : null, target, ref left, ref top, ref right, ref bottom, ref found);
			TMP_InputField? inputField = GetInputField();
			IncludeChatVisualRect((inputField != null) ? ((Component)inputField).GetComponent<RectTransform>() : null, target, ref left, ref top, ref right, ref bottom, ref found);
			if (!found)
			{
				target.GetWorldCorners(WorldCornersB);
				IncludeWorldCorners(ref left, ref top, ref right, ref bottom);
			}
			return Rect.MinMaxRect(left, bottom, right, top);
		}

		private static Rect GetScreenBounds(RectTransform rect)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return ClanUiFactory.GetScreenBounds(rect, null);
		}

		private static Rect GetSafeArea()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Rect safeArea = Screen.safeArea;
			if (!(((Rect)(ref safeArea)).width > 0f) || !(((Rect)(ref safeArea)).height > 0f))
			{
				return new Rect(0f, 0f, (float)Screen.width, (float)Screen.height);
			}
			return safeArea;
		}

		private static bool IsFiniteNonTrivialRect(Rect rect)
		{
			if (((Rect)(ref rect)).width > 1f && ((Rect)(ref rect)).height > 1f && IsFinite(((Rect)(ref rect)).xMin) && IsFinite(((Rect)(ref rect)).yMin) && IsFinite(((Rect)(ref rect)).xMax))
			{
				return IsFinite(((Rect)(ref rect)).yMax);
			}
			return false;
		}

		private static void IncludeChatVisualRect(RectTransform? rect, RectTransform target, ref float left, ref float top, ref float right, ref float bottom, ref bool found)
		{
			if (!((Object)(object)rect == (Object)null) && (!((Object)(object)rect != (Object)(object)target) || ((Component)rect).transform.IsChildOf(((Component)target).transform)))
			{
				rect.GetWorldCorners(WorldCornersB);
				IncludeWorldCorners(ref left, ref top, ref right, ref bottom);
				found = true;
			}
		}

		private static void IncludeWorldCorners(ref float left, ref float top, ref float right, ref float bottom)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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)
			for (int i = 0; i < WorldCornersB.Length; i++)
			{
				Vector2 val = RectTransformUtility.WorldToScreenPoint((Camera)null, WorldCornersB[i]);
				left = Mathf.Min(left, val.x);
				top = Mathf.Max(top, val.y);
				right = Mathf.Max(right, val.x);
				bottom = Mathf.Min(bottom, val.y);
			}
		}

		private static void RefreshChatScaleTarget(RectTransform? target, bool canResize)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (!canResize || (Object)(object)target == (Object)null)
			{
				ReleaseChatScaleTarget(restoreScale: true);
				return;
			}
			if ((Object)(object)_chatScaleTarget != (Object)(object)target)
			{
				ReleaseChatScaleTarget(restoreScale: true);
				_chatScaleTarget = target;
				_chatBaseLocalScale = ((Transform)target).localScale;
				_chatScaleFactor = 1f;
			}
			if (!_isChatScaleDragging)
			{
				TMP_InputField inputField = GetInputField();
				if (!((Object)(object)inputField == (Object)null) && ((Component)inputField).gameObject.activeInHierarchy && HasUsableChatVisualGeometry(target))
				{
					SetChatScale(ClanPlugin.ClanChatWindowScale.Value);
				}
			}
		}

		private static void ReleaseChatScaleTarget(bool restoreScale)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			RectTransform chatScaleTarget = _chatScaleTarget;
			if (restoreScale && (Object)(object)chatScaleTarget != (Object)null && Mathf.Abs(_chatScaleFactor - 1f) > 0.001f)
			{
				SetTargetScaleKeepingVisualBottomRight(chatScaleTarget, _chatBaseLocalScale);
			}
			_chatScaleTarget = null;
			_chatBaseLocalScale = Vector3.one;
			_chatScaleFactor = 1f;
			_isChatScaleDragging = false;
		}

		private static void BeginChatScaleDrag()
		{
			if (!((Object)(object)_chatScaleTarget == (Object)null) && _canResizeChatPanel)
			{
				_isChatScaleDragging = true;
				RefocusChatInput();
			}
		}

		private static void DragChatScale(Vector2 screenDelta)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			RectTransform chatScaleTarget = _chatScaleTarget;
			if (_isChatScaleDragging && !((Object)(object)chatScaleTarget == (Object)null) && _canResizeChatPanel)
			{
				Rect chatVisualScreenBounds = GetChatVisualScreenBounds(chatScaleTarget);
				float num = Mathf.Max(1f, ((Rect)(ref chatVisualScreenBounds)).width);
				float num2 = Mathf.Max(1f, ((Rect)(ref chatVisualScreenBounds)).height);
				float num3 = (0f - screenDelta.x) / num;
				float num4 = screenDelta.y / num2;
				float num5 = Mathf.Max(0.1f, 1f + (num3 + num4) * 0.5f);
				SetChatScale(_chatScaleFactor * num5);
				TMP_InputField inputField = GetInputField();
				if ((Object)(object)inputField != (Object)null)
				{
					RefreshDockPositions(inputField);
				}
			}
		}

		private static void EndChatScaleDrag(bool save)
		{
			if (_isChatScaleDragging)
			{
				_isChatScaleDragging = false;
				if (save)
				{
					ClanPlugin.ClanChatWindowScale.Value = _chatScaleFactor;
				}
				RefocusChatInput();
			}
		}

		private static void SetChatScale(float requestedScale)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			RectTransform chatScaleTarget = _chatScaleTarget;
			if (!((Object)(object)chatScaleTarget == (Object)null))
			{
				if (float.IsNaN(requestedScale) || float.IsInfinity(requestedScale))
				{
					requestedScale = 1f;
				}
				float num = CalculateMaximumChatScale(chatScaleTarget);
				float num2 = Mathf.Clamp(requestedScale, 1f, num);
				if (!(Mathf.Abs(num2 - _chatScaleFactor) <= 0.0001f))
				{
					SetTargetScaleKeepingVisualBottomRight(chatScaleTarget, new Vector3(_chatBaseLocalScale.x * num2, _chatBaseLocalScale.y * num2, _chatBaseLocalScale.z));
					_chatScaleFactor = num2;
				}
			}
		}

		private static float CalculateMaximumChatScale(RectTransform target)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_0089: 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)
			Rect chatVisualScreenBounds = GetChatVisualScreenBounds(target);
			Rect safeArea = GetSafeArea();
			if (!IsUsableChatPlacementBounds(chatVisualScreenBounds, safeArea))
			{
				return 2f;
			}
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(((Rect)(ref chatVisualScreenBounds)).xMax, ((Rect)(ref chatVisualScreenBounds)).yMin);
			float num = Mathf.Max(1f, val.x - ((Rect)(ref chatVisualScreenBounds)).xMin) / Mathf.Max(0.001f, _chatScaleFactor);
			float num2 = Mathf.Max(1f, ((Rect)(ref chatVisualScreenBounds)).yMax - val.y) / Mathf.Max(0.001f, _chatScaleFactor);
			float num3 = Mathf.Max(1f, val.x - ((Rect)(ref safeArea)).xMin - 4f);
			float num4 = Mathf.Max(1f, ((Rect)(ref safeArea)).yMax - val.y - 4f);
			return Mathf.Clamp(Mathf.Min(num3 / num, num4 / num2), 1f, 2f);
		}

		private static void SetTargetScaleKeepingVisualBottomRight(RectTransform target, Vector3 localScale)
		{
			//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_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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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)
			Rect chatVisualScreenBounds = GetChatVisualScreenBounds(target);
			target.GetWorldCorners(WorldCornersA);
			Vector3 val = WorldCornersA[3];
			((Transform)target).localScale = localScale;
			Rect chatVisualScreenBounds2 = GetChatVisualScreenBounds(target);
			Transform parent = ((Transform)target).parent;
			RectTransform val2 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			Vector2 val3 = default(Vector2);
			Vector2 val4 = default(Vector2);
			if (val2 != null && RectTransformUtility.ScreenPointToLocalPointInRectangle(val2, new Vector2(((Rect)(ref chatVisualScreenBounds)).xMax, ((Rect)(ref chatVisualScreenBounds)).yMin), (Camera)null, ref val3) && RectTransformUtility.ScreenPointToLocalPointInRectangle(val2, new Vector2(((Rect)(ref chatVisualScreenBounds2)).xMax, ((Rect)(ref chatVisualScreenBounds2)).yMin), (Camera)null, ref val4))
			{
				target.anchoredPosition += val3 - val4;
				return;
			}
			target.GetWorldCorners(WorldCornersB);
			((Transform)target).position = ((Transform)target).position + (val - WorldCornersB[3]);
		}

		private static void ApplyClanDockScale(float? scaleOverride = null)
		{
			//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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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)
			float num = scaleOverride ?? ((_canResizeChatPanel && (Object)(object)_chatScaleTarget == (Object)(object)_chatPanelRect) ? _chatScaleFactor : 1f);
			Vector3 scale = default(Vector3);
			((Vector3)(ref scale))..ctor(num, num, 1f);
			SetDockScale(_emojiButtonDockRect, scale);
			SetDockScale(_clanButtonDockRect, scale);
			SetDockScale(_chatViewDockRect, scale);
			SetDockScale(_channelDockRect, scale);
			SetDockScale(_commandDockRect, scale);
			SetDockScale(_emojiTrayRect, scale);
		}

		private static void SetDockScale(RectTransform? rect, Vector3 scale)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rect != (Object)null)
			{
				((Transform)rect).localScale = scale;
			}
		}

		private static void CycleChatViewMode()
		{
			bool hasClan = ClanRpc.CurrentSnapshot.HasClan;
			_chatViewMode = _chatViewMode switch
			{
				ChatViewMode.All => hasClan ? ChatViewMode.Clan : ChatViewMode.Local, 
				ChatViewMode.Clan => ChatViewMode.Local, 
				ChatViewMode.Local => ChatViewMode.Global, 
				_ => ChatViewMode.All, 
			};
			RefreshChatViewButton(refreshTooltip: true);
			RefreshChatViewOutput(resetScroll: true);
		}

		private static void RefreshChatViewButton(bool refreshTooltip)
		{
			//IL_002e: 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_003d: 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)
			(string, string, string) chatViewPresentation = GetChatViewPresentation();
			SetButtonLabel(_chatViewButton, chatViewPresentation.Item1);
			bool flag = _chatViewMode != ChatViewMode.All;
			SetButtonColor(_chatViewButton, flag ? ActiveToggleButtonColor : InactiveToggleButtonColor, flag ? Color.white : InactiveButtonLabelColor);
			if (refreshTooltip && (Object)(object)_chatViewButton != (Object)null)
			{
				ClanUiFeedback.SetTooltip((Selectable)(object)_chatViewButton, chatViewPresentation.Item2, richText: false, ClanTooltipPlacement.LeftOfTarget);
			}
			if ((Object)(object)_chatViewButton != (Object)null)
			{
				UpdatePlaceholder();
			}
		}

		private static (string Label, string Tooltip, string PlaceholderSummary) GetChatViewPresentation()
		{
			return _chatViewMode switch
			{
				ChatViewMode.Clan => (Label: ClanLocalization.Text("chat_filter_clan"), Tooltip: ClanLocalization.Text("chat_filter_tooltip_clan"), PlaceholderSummary: ClanLocalization.Text("chat_filter_view_clan")), 
				ChatViewMode.Local => (Label: ClanLocalization.Text("chat_filter_local"), Tooltip: ClanLocalization.Text("chat_filter_tooltip_local"), PlaceholderSummary: ClanLocalization.Text("chat_filter_view_local")), 
				ChatViewMode.Global => (Label: ClanLocalization.Text("chat_filter_global"), Tooltip: ClanLocalization.Text("chat_filter_tooltip_global"), PlaceholderSummary: ClanLocalization.Text("chat_filter_view_global")), 
				_ => (Label: ClanLocalization.Text("chat_filter_all"), Tooltip: ClanLocalization.Text("chat_filter_tooltip_all"), PlaceholderSummary: ClanLocalization.Text("chat_filter_view_all")), 
			};
		}

		private static Button AddChannelButton(Transform parent, Channel channel, string label, float width)
		{
			Button val = CreateButton(parent, label, delegate
			{
				_activeChannel = ((_activeChannel != channel) ? channel : Channel.Say);
				NormalizeUiState(ClanRpc.CurrentSnapshot);
				UpdatePlaceholder();
				RefreshButtonStates();
			}, width);
			ChannelButtons[channel] = val;
			AddPreferredHeight(((Component)val).gameObject, 30f);
			return val;
		}

		private static Button AddCommandButton(Transform parent, string label, CommandAction action, float width)
		{
			Button obj = CreateButton(parent, label, delegate
			{
				ConfirmOrRunCommand(action);
			}, width);
			AddPreferredHeight(((Component)obj).gameObject, 30f);
			return obj;
		}

		private static void RefreshConfiguredChannelVisibility()
		{
			if ((Object)(object)_whisperButton == (Object)null)
			{
				return;
			}
			bool flag = ClanPlugin.ShowWhisperChatButton.Value.IsOn();
			if (((Component)_whisperButton).gameObject.activeSelf != flag)
			{
				((Component)_whisperButton).gameObject.SetActive(flag);
				if (!flag && _activeChannel == Channel.Whisper)
				{
					_activeChannel = Channel.Say;
					UpdatePlaceholder();
				}
				if ((Object)(object)_channelDockRect != (Object)null)
				{
					LayoutRebuilder.ForceRebuildLayoutImmediate(_channelDockRect);
				}
				RefreshButtonStates();
			}
		}

		private static void RefreshConfiguredCommandVisibility()
		{
			if (!((Object)(object)_commandDockRect == (Object)null) && !((Object)(object)_resetSpawnButton == (Object)null) && !((Object)(object)_dieButton == (Object)null))
			{
				bool flag = ClanPlugin.ShowResetSpawnButton.Value.IsOn();
				bool flag2 = ClanPlugin.ShowDieButton.Value.IsOn();
				bool flag3 = false;
				if (((Component)_resetSpawnButton).gameObject.activeSelf != flag)
				{
					((Component)_resetSpawnButton).gameObject.SetActive(flag);
					flag3 = true;
				}
				if (((Component)_dieButton).gameObject.activeSelf != flag2)
				{
					((Component)_dieButton).gameObject.SetActive(flag2);
					flag3 = true;
				}
				bool flag4 = flag || flag2;
				if (((Component)_commandDockRect).gameObject.activeSelf != flag4)
				{
					((Component)_commandDockRect).gameObject.SetActive(flag4);
					flag3 = true;
				}
				if ((_pendingCommand == CommandAction.ResetSpawn && !flag) || (_pendingCommand == CommandAction.Die && !flag2))
				{
					CancelCommandConfirmation();
				}
				if (flag3 && flag4)
				{
					LayoutRebuilder.ForceRebuildLayoutImmediate(_commandDockRect);
				}
			}
		}

		private static void ConfirmOrRunCommand(CommandAction action)
		{
			if (action == CommandAction.None)
			{
				return;
			}
			if (_pendingCommand != action || Time.unscaledTime > _commandConfirmationExpiresAt)
			{
				_pendingCommand = action;
				_commandConfirmationExpiresAt = Time.unscaledTime + 3f;
				RefreshCommandButtonStates();
				return;
			}
			_pendingCommand = CommandAction.None;
			_commandConfirmationExpiresAt = 0f;
			RefreshCommandButtonStates();
			Chat instance = Chat.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				string text = ((action == CommandAction.ResetSpawn) ? "resetspawn" : "die");
				((Terminal)instance).TryRunCommand(text, true, false);
				ResetChatHideTimer(instance);
			}
		}

		private static void ExpireCommandConfirmation()
		{
			if (_pendingCommand != CommandAction.None && Time.unscaledTime > _commandConfirmationExpiresAt)
			{
				CancelCommandConfirmation();
			}
		}

		private static void CancelCommandConfirmation()
		{
			if (_pendingCommand != CommandAction.None)
			{
				_pendingCommand = CommandAction.None;
				_commandConfirmationExpiresAt = 0f;
				RefreshCommandButtonStates();
			}
		}

		private static void RefreshCommandButtonStates()
		{
			//IL_0067: 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_006c: 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_007e: 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)
			bool flag = _pendingCommand == CommandAction.ResetSpawn;
			bool flag2 = _pendingCommand == CommandAction.Die;
			SetButtonLabel(_resetSpawnButton, flag ? ClanLocalization.Text("chat_command_reset_spawn_confirm") : ClanLocalization.Text("chat_command_reset_spawn"));
			SetButtonLabel(_dieButton, flag2 ? ClanLocalization.Text("chat_command_die_confirm") : ClanLocalization.Text("chat_command_die"));
			SetButtonColor(_resetSpawnButton, flag ? ConfirmationButtonColor : ButtonColor, Color.white);
			SetButtonColor(_dieButton, flag2 ? ConfirmationButtonColor : ButtonColor, Color.white);
		}

		private static void RefreshButtonStates()
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: 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_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_007a: 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_0155: 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_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_0170: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_root == (Object)null)
			{
				return;
			}
			ClanClientSnapshot currentSnapshot = ClanRpc.CurrentSnapshot;
			foreach (KeyValuePair<Channel, Button> channelButton in ChannelButtons)
			{
				Button value = channelButton.Value;
				if (!((Object)(object)value == (Object)null))
				{
					bool flag = channelButton.Key != Channel.Clan || currentSnapshot.HasClan;
					bool flag2 = flag && channelButton.Key == _activeChannel;
					((Selectable)value).interactable = flag;
					SetButtonColor(value, (!flag) ? DisabledButtonColor : (flag2 ? ActiveToggleButtonColor : InactiveToggleButtonColor), (!flag) ? DisabledButtonLabelColor : (flag2 ? Color.white : InactiveButtonLabelColor));
				}
			}
			if ((Object)(object)_clanPanelButton != (Object)null)
			{
				bool isOpen = ClanPanelController.IsOpen;
				bool flag3 = HasActionableClanNotification(currentSnapshot);
				SetButtonColor(_clanPanelButton, isOpen ? ActiveToggleButtonColor : InactiveToggleButtonColor, flag3 ? ClanUiFeedback.GetNotificationPulseColor() : (isOpen ? Color.white : InactiveButtonLabelColor));
			}
			if ((Object)(object)_emojiTrayButton != (Object)null)
			{
				bool isReady = ClanEmoji.IsReady;
				bool flag4 = isReady && _emojiTrayOpen;
				((Selectable)_emojiTrayButton).interactable = isReady;
				SetButtonColor(_emojiTrayButton, (!isReady) ? DisabledButtonColor : (flag4 ? ActiveToggleButtonColor : InactiveToggleButtonColor), (!isReady) ? DisabledButtonLabelColor : (flag4 ? Color.white : InactiveButtonLabelColor));
			}
			RefreshChatViewButton(refreshTooltip: false);
			RefreshCommandButtonStates();
		}

		private static void RefreshClanNotificationPulse(ClanClientSnapshot snapshot)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_clanPanelButton == (Object)null) && !((Object)(object)_clanPanelButtonLabel == (Object)null))
			{
				bool isOpen = ClanPanelController.IsOpen;
				((Graphic)_clanPanelButtonLabel).color = (HasActionableClanNotification(snapshot) ? ClanUiFeedback.GetNotificationPulseColor() : (isOpen ? Color.white : InactiveButtonLabelColor));
			}
		}

		private static void NormalizeUiState(ClanClientSnapshot snapshot)
		{
			if (!snapshot.HasClan && _chatViewMode == ChatViewMode.Clan)
			{
				_chatViewMode = ChatViewMode.All;
				RefreshChatViewButton(refreshTooltip: true);
				RefreshChatViewOutput(resetScroll: true);
			}
			if (!snapshot.HasClan && _activeChannel == Channel.Clan)
			{
				_activeChannel = Channel.Say;
			}
			if (!ClanPlugin.ShowWhisperChatButton.Value.IsOn() && _activeChannel == Channel.Whisper)
			{
				_activeChannel = Channel.Say;
			}
			if (!ClanEmoji.IsReady && _emojiTrayOpen)
			{
				_emojiTrayOpen = false;
				if ((Object)(object)_emojiTray != (Object)null)
				{
					_emojiTray.SetActive(false);
				}
			}
		}

		private static void RefreshUi(ClanClientSnapshot snapshot)
		{
			NormalizeUiState(snapshot);
			RefreshButtonStates();
			ClanPanelController.RefreshSnapshot(snapshot);
			UpdatePlaceholder();
		}

		private static void RouteInput(Chat chat)
		{
			TMP_InputField inputField = GetInputField(chat);
			if ((Object)(object)inputField == (Object)null)
			{
				return;
			}
			string text = inputField.text.Trim();
			if (!string.IsNullOrWhiteSpace(text))
			{
				switch (_activeChannel)
				{
				case Channel.Shout:
					chat.SendText((Type)2, text);
					break;
				case Channel.Whisper:
					chat.SendText((Type)0, text);
					break;
				case Channel.Clan:
					ClanRpc.Send(new ClanRequest
					{
						Type = ClanRequestType.SendClanChat,
						ClanId = ClanRpc.CurrentSnapshot.ClanId,
						Message = text
					});
					break;
				default:
					chat.SendText((Type)1, text);
					break;
				}
				CompleteChatSubmission(chat);
			}
		}

		private static bool ShouldRouteInput(Chat chat)
		{
			TMP_InputField inputField = GetInputField(chat);
			if ((Object)(object)_root == (Object)null || !_root.activeInHierarchy || (Object)(object)inputField == (Object)null || !IsChatInputOpen(inputField))
			{
				return false;
			}
			string text = inputField.text.TrimStart(Array.Empty<char>());
			if (!string.IsNullOrWhiteSpace(text))
			{
				return !text.StartsWith("/", StringComparison.Ordinal);
			}
			return false;
		}

		private static bool IsVanillaChatCommand(Chat chat)
		{
			TMP_InputField inputField = GetInputField(chat);
			if ((Object)(object)inputField == (Object)null)
			{
				return false;
			}
			string text = inputField.text.TrimStart(Array.Empty<char>());
			int num = text.IndexOf(' ');
			if (num <= 1 || num >= text.Length - 1 || text[0] != '/')
			{
				return false;
			}
			string x = text.Substring(1, num - 1);
			if (!string.IsNullOrWhiteSpace(text.Substring(num + 1)))
			{
				if (!StringComparer.OrdinalIgnoreCase.Equals(x, "say") && !StringComparer.OrdinalIgnoreCase.Equals(x, "s"))
				{
					return StringComparer.OrdinalIgnoreCase.Equals(x, "w");
				}
				return true;
			}
			return false;
		}

		private static void CompleteChatSubmission(Chat chat)
		{
			if (ClanPanelController.IsOpen)
			{
				CloseEmojiTray();
				RefreshButtonStates();
			}
			else
			{
				CloseOverlays();
			}
			if (ClanPlugin.ChatAfterSend.Value == ClanPlugin.ChatSubmitMode.KeepOpen)
			{
				ScheduleChatRefocus(chat);
			}
			else
			{
				CancelPendingChatRefocus();
			}
		}

		private static void UpdatePlaceholder()
		{
			if (SupportsCurrentChatUi)
			{
				TMP_InputField? inputField = GetInputField();
				Graphic obj = ((inputField != null) ? inputField.placeholder : null);
				TMP_Text val = (TMP_Text)(object)((obj is TMP_Text) ? obj : null);
				if (val != null)
				{
					string text = _activeChannel switch
					{
						Channel.Say => ClanLocalization.Text("chat_placeholder_say"), 
						Channel.Shout => ClanLocalization.Text("chat_placeholder_shout"), 
						Channel.Whisper => ClanLocalization.Text("chat_placeholder_whisper"), 
						Channel.Clan => ClanLocalization.Text("chat_placeholder_clan"), 
						_ => ClanLocalization.Text("chat_placeholder_default"), 
					};
					val.text = ClanLocalization.Format("chat_placeholder_with_filter", text, GetChatViewPresentation().PlaceholderSummary);
				}
			}
		}

		private static TMP_InputField? GetInputField()
		{
			if (!((Object)(object)Chat.instance == (Object)null))
			{
				return GetInputField(Chat.instance);
			}
			return null;
		}

		private static TMP_InputField? GetInputField(Chat chat)
		{
			return (TMP_InputField?)(object)((Terminal)chat).m_input;
		}

		private static bool IsUnsupportedReplacementChat(Chat chat)
		{
			if (StringComparer.Ordinal.Equals(((Object)((Component)chat).gameObject).name, "KGChat"))
			{
				return true;
			}
			TMP_InputField inputField = GetInputField(chat);
			RectTransform chatWindow = ((Terminal)chat).m_chatWindow;
			Component output = (Component)(object)((Terminal)chat).m_output;
			if ((Object)(object)inputField == (Object)null || (Object)(object)chatWindow == (Object)null || (Object)(object)output == (Object)null)
			{
				return true;
			}
			Transform transform = ((Component)inputField).transform;
			Transform transform2 = output.transform;
			Transform transform3 = ((Component)chatWindow).transform;
			bool num = (Object)(object)transform == (Object)(object)transform3 || transform.IsChildOf(transform3);
			bool flag = (Object)(object)transform2 == (Object)(object)transform3 || transform2.IsChildOf(transform3);
			if (num)
			{
				return !flag;
			}
			return true;
		}

		private static void DisableDockForUnsupportedChat(Chat chat)
		{
			DestroyRoot();
			if (_unsupportedChatWarningOwner != chat)
			{
				_unsupportedChatWarningOwner = chat;
				string text = ClanLocalization.Text("chat_replacement_unsupported");
				ClanPlugin.ClanLogger.LogWarning((object)text);
				ClanRpc.NotifyStatus(text);
			}
		}

		private static void OnSnapshotChanged(ClanClientSnapshot snapshot)
		{
			RefreshUi(snapshot);
		}

		private static void OnDirectoryChanged(ClanDirectorySnapshot directory)
		{
			ClanPanelController.RefreshDirectory(directory);
		}

		private static void OnEmojiChanged()
		{
			RebuildEmojiTrayContent();
			NormalizeUiState(ClanRpc.CurrentSnapshot);
			RefreshButtonStates();
			UpdatePlaceholder();
		}

		private static void OnEmblemsChanged()
		{
			ClanPanelController.OnEmblemsChanged();
		}

		private static void OnClanPanelOpenStateChanged(bool isOpen)
		{
			if (!isOpen)
			{
				_keepChatVisibleForClanPanel = false;
			}
			RefreshButtonStates();
			RefreshClanPanelTooltip();
		}

		private static void OnPanelShortcutChanged(object sender, EventArgs args)
		{
			RefreshClanPanelTooltip();
			RefreshEmojiPanelTooltip();
		}

		private unsafe static void RefreshEmojiPanelTooltip()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_emojiTrayButton == (Object)null)
			{
				return;
			}
			if (_emojiTrayOpen)
			{
				ClanUiFeedback.SetTooltip((Selectable)(object)_emojiTrayButton, ClanLocalization.Text("emoji_panel_tooltip_click_close"), richText: false, ClanTooltipPlacement.LeftOfTarget);
				return;
			}
			KeyboardShortcut value = ClanPlugin.EmojiPanelShortcut.Value;
			if ((int)((KeyboardShortcut)(ref value)).MainKey == 0)
			{
				ClanUiFeedback.SetTooltip((Selectable)(object)_emojiTrayButton, ClanLocalization.Text("emoji_panel_tooltip_click_open"), richText: false, ClanTooltipPlacement.LeftOfTarget);
				return;
			}
			string text = ((object)(*(KeyboardShortcut*)(&value))/*cast due to .constrained prefix*/).ToString();
			if (string.IsNullOrWhiteSpace(text))
			{
				text = ((object)((KeyboardShortcut)(ref value)).MainKey/*cast due to .constrained prefix*/).ToString();
			}
			ClanUiFeedback.SetTooltip((Selectable)(object)_emojiTrayButton, ClanLocalization.Format("emoji_panel_tooltip_press_open", text), richText: true, ClanTooltipPlacement.LeftOfTarget);
		}

		private unsafe static void RefreshClanPanelTooltip()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_clanPanelButton == (Object)null)
			{
				return;
			}
			KeyboardShortcut value = ClanPlugin.ClanPanelShortcut.Value;
			bool isOpen = ClanPanelController.IsOpen;
			if ((int)((KeyboardShortcut)(ref value)).MainKey == 0)
			{
				ClanUiFeedback.SetTooltip((Selectable)(object)_clanPanelButton, ClanLocalization.Text(isOpen ? "clan_panel_tooltip_click_close" : "clan_panel_tooltip_click_open"), richText: false, ClanTooltipPlacement.LeftOfTarget);
				return;
			}
			string text = ((object)(*(KeyboardShortcut*)(&value))/*cast due to .constrained prefix*/).ToString();
			if (string.IsNullOrWhiteSpace(text))
			{
				text = ((object)((KeyboardShortcut)(ref value)).MainKey/*cast due to .constrained prefix*/).ToString();
			}
			ClanUiFeedback.SetTooltip((Selectable)(object)_clanPanelButton, ClanLocalization.Format(isOpen ? "clan_panel_tooltip_press_close" : "clan_panel_tooltip_press_open", text), richText: true, ClanTooltipPlacement.LeftOfTarget);
		}

		private static void OnStatusReceived(string status)
		{
			if (!string.IsNullOrWhiteSpace(status))
			{
				AddVanillaLine(Clean(status).Replace("\n", " "), ChatLineKind.System);
			}
		}

		private static void OnClanChatReceived(string senderName, string message)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			AddVanillaLine("<color=orange>" + Clean(senderName) + "</color>: <color=#" + ColorUtility.ToHtmlStringRGBA(ClanUiFactory.GetClanColor()) + ">" + Clean(message) + "</color>", ChatLineKind.Clan);
		}

		private static void AddVanillaLine(string message, ChatLineKind kind)
		{
			Chat instance = Chat.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				ChatLineKindScope scope = PushChatLineKind(kind);
				try
				{
					((Terminal)instance).AddString("<color=#66d9c8>[" + ClanLocalization.Text("chat_clan_tag") + "]</color> " + message);
				}
				finally
				{
					RestoreChatLineKind(scope);
				}
				if (IsChatLineVisible(kind))
				{
					ResetChatHideTimer(instance);
				}
			}
		}

		private static ChatLineKindScope PushChatLineKind(ChatLineKind kind)
		{
			ChatLineKindScope result = new ChatLineKindScope(_scopedChatLineKind);
			_scopedChatLineKind = kind;
			return result;
		}

		private static ChatLineKindScope PushChatLineKind(Type type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected I4, but got Unknown
			return PushChatLineKind((int)type switch
			{
				1 => ChatLineKind.Local, 
				0 => ChatLineKind.Local, 
				2 => ChatLineKind.Global, 
				_ => ChatLineKind.System, 
			});
		}

		private static void RestoreChatLineKind(ChatLineKindScope scope)
		{
			_scopedChatLineKind = scope.Previous;
		}

		private static void ResetChatHistoryTracking(Chat? chat)
		{
			ResetChatPlacementCache();
			_trackedChat = chat;
			ChatLineKinds.Clear();
			_chatHistoryMismatchWarned = false;
			_chatFilterUnavailableWarned = false;
			_chatViewMode = ChatViewMode.All;
			if ((Object)(object)chat != (Object)null && TryGetChatBuffer((Terminal)(object)chat, out List<string> buffer))
			{
				for (int i = 0; i < buffer.Count; i++)
				{
					ChatLineKinds.Add(ChatLineKind.System);
				}
			}
			RefreshChatViewButton(refreshTooltip: true);
		}

		private static bool EnsureTrackedChat(Terminal terminal)
		{
			Chat val = (Chat)(object)((terminal is Chat) ? terminal : null);
			if (val == null || (Object)(object)Chat.instance == (Object)null || val != Chat.instance)
			{
				return false;
			}
			if (_trackedChat != val)
			{
				ResetChatHistoryTracking(val);
			}
			return true;
		}

		private static bool TryGetChatBuffer(Terminal terminal, out List<string> buffer)
		{
			buffer = null;
			if (ChatBufferField == null)
			{
				WarnChatFilterUnavailable("Chat history filtering is unavailable because the vanilla chat buffer was not found.");
				return false;
			}
			try
			{
				if (ChatBufferField.GetValue(terminal) is List<string> list)
				{
					buffer = list;
					return true;
				}
			}
			catch (Exception ex)
			{
				WarnChatFilterUnavailable("Chat history filtering is unavailable: " + ex.GetBaseException().Message);
				return false;
			}
			WarnChatFilterUnavailable("Chat history filtering is unavailable because the vanilla chat buffer has an unexpected type.");
			return false;
		}

		private static void EnsureChatHistoryAligned(List<string> buffer)
		{
			if (ChatLineKinds.Count == buffer.Count)
			{
				return;
			}
			if (buffer.Count == 0)
			{
				ChatLineKinds.Clear();
				return;
			}
			int count = ChatLineKinds.Count;
			ChatLineKinds.Clear();
			for (int i = 0; i < buffer.Count; i++)
			{
				ChatLineKinds.Add(ChatLineKind.System);
			}
			if (!_chatHistoryMismatchWarned)
			{
				_chatHistoryMismatchWarned = true;
				ClanPlugin.ClanLogger.LogWarning((object)$"Chat history changed outside Clan ({count} tracked, {buffer.Count} actual). Existing lines were kept visible in every filter; new lines will be classified normally.");
			}
		}

		private static void PrepareTrackedChatLine(Terminal terminal)
		{
			if (EnsureTrackedChat(terminal) && TryGetChatBuffer(terminal, out List<string> buffer))
			{
				EnsureChatHistoryAligned(buffer);
				while (ChatLineKinds.Count >= 300)
				{
					ChatLineKinds.RemoveAt(0);
				}
				ChatLineKinds.Add(_scopedChatLineKind);
			}
		}

		private static bool IsChatLineVisible(ChatLineKind kind)
		{
			if (_chatViewMode == ChatViewMode.All || kind == ChatLineKind.System)
			{
				return true;
			}
			return _chatViewMode switch
			{
				ChatViewMode.Clan => kind == ChatLineKind.Clan, 
				ChatViewMode.Local => kind == ChatLineKind.Local, 
				ChatViewMode.Global => kind == ChatLineKind.Global, 
				_ => true, 
			};
		}

		private static void RefreshChatViewOutput(bool resetScroll)
		{
			Chat instance = Chat.instance;
			if ((Object)(object)instance == (Object)null || IsUnsupportedReplacementChat(instance))
			{
				return;
			}
			try
			{
				if (resetScroll && ChatScrollHeightField != null)
				{
					ChatScrollHeightField.SetValue(instance, 0);
				}
				if (TerminalUpdateChatMethod == null)
				{
					WarnChatFilterUnavailable("Chat history filtering is unavailable because the vanilla renderer was not found.");
				}
				else
				{
					TerminalUpdateChatMethod.Invoke(instance, null);
				}
			}
			catch (Exception ex)
			{
				WarnChatFilterUnavailable("Chat history filtering could not refresh the chat panel: " + ex.GetBaseException().Message);
			}
		}

		private static bool TryRenderFilteredChat(Terminal terminal)
		{
			if (_chatViewMode == ChatViewMode.All)
			{
				return false;
			}
			if (EnsureTrackedChat(terminal) && _chatViewMode != ChatViewMode.All)
			{
				Chat val = (Chat)(object)((terminal is Chat) ? terminal : null);
				if (val != null && !IsUnsupportedReplacementChat(val))
				{
					try
					{
						if (TryGetChatBuffer(terminal, out List<string> buffer) && !(ChatScrollHeightField == null) && !(ChatVisibleBufferLengthField == null))
						{
							TMP_Text output = (TMP_Text)(object)terminal.m_output;
							if (output != null)
							{
								EnsureChatHistoryAligned(buffer);
								List<string> list = new List<string>(buffer.Count);
								for (int i = 0; i < buffer.Count; i++)
								{
									if (IsChatLineVisible(ChatLineKinds[i]))
									{
										list.Add(buffer[i]);
									}
								}
								int num = ((ChatScrollHeightField.GetValue(terminal) is int num2) ? num2 : 0);
								int num3 = ((ChatVisibleBufferLengthField.GetValue(terminal) is int num4) ? num4 : 30);
								int num5 = Mathf.Clamp(num, 0, Mathf.Max(0, list.Count - 5));
								if (num5 != num)
								{
									ChatScrollHeightField.SetValue(terminal, num5);
								}
								int num6 = Mathf.Min(list.Count, Mathf.Max(5, list.Count - num5));
								int num7 = Mathf.Max(0, num6 - num3);
								StringBuilder stringBuilder = new StringBuilder();
								for (int j = num7; j < num6; j++)
								{
									stringBuilder.Append(list[j]);
									stringBuilder.Append('\n');
								}
								output.text = stringBuilder.ToString();
								return true;
							}
						}
						WarnChatFilterUnavailable("Chat history filtering is unavailable because a vanilla chat field was not found.");
						return false;
					}
					catch (Exception ex)
					{
						WarnChatFilterUnavailable("Chat history filtering was bypassed after an error: " + ex.GetBaseException().Message);
						return false;
					}
				}
			}
			return false;
		}

		private static void WarnChatFilterUnavailable(string message)
		{
			_chatViewMode = ChatViewMode.All;
			RefreshChatViewButton(refreshTooltip: true);
			if (!_chatFilterUnavailableWarned)
			{
				_chatFilterUnavailableWarned = true;
				ClanPlugin.ClanLogger.LogWarning((object)message);
			}
		}

		private static string Clean(string value)
		{
			return (value ?? "").Replace("<", " ").Replace(">", " ").Trim();
		}

		private static Text CreateLabel(Transform parent, string text, int fontSize, TextAnchor alignment)
		{
			//IL_0032: 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)
			Text component = ClanUiFactory.CreateObject("Text", parent, typeof(Text)).GetComponent<Text>();
			component.text = text;
			component.fontSize = fontSize;
			component.alignment = alignment;
			((Graphic)component).color = Color.white;
			component.font = ClanUiFactory.GetBoldFont();
			component.supportRichText = true;
			component.horizontalOverflow = (HorizontalWrapMode)0;
			component.verticalOverflow = (VerticalWrapMode)0;
			return component;
		}

		private static Button CreateButton(Transform parent, string text, Action onClick, float width)
		{
			//IL_0041: 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: Expected O, but got Unknown
			//IL_008b: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = ClanUiFactory.CreateObject("Button", parent, typeof(Image), typeof(Button));
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = Color.white;
			Button component2 = val.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			val.AddComponent<DockPointerFocusKeeper>();
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				onClick();
				RefocusChatInput();
			});
			RectTransform component3 = ((Component)CreateLabel(val.transform, text, 12, (TextAnchor)4)).GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.offsetMin = Vector2.zero;
			component3.offsetMax = Vector2.zero;
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredWidth = width;
			obj.minWidth = width;
			TryApplyButtonStyle(component2);
			SetButtonColor(component2, ButtonColor, Color.white);
			return component2;
		}

		private static void SetButtonLabel(Button? button, string text)
		{
			if ((Object)(object)button == (Object)null)
			{
				return;
			}
			Text[] componentsInChildren = ((Component)button).GetComponentsInChildren<Text>(true);
			foreach (Text val in componentsInChildren)
			{
				if ((Object)(object)((Component)val).transform.parent == (Object)(object)((Component)button).transform)
				{
					val.text = text;
					break;
				}
			}
		}

		private static void RemoveVanillaStartupHelp(Chat chat)
		{
			if (Localization.instance == null)
			{
				return;
			}
			string text = "Emotes: " + string.Join(", ", from index in Enumerable.Range(0, 25)
				select ((object)(Emotes)index/*cast due to .constrained prefix*/).ToString().ToLower());
			string[] array = new string[7]
			{
				Localization.instance.Localize("/w [text] - $chat_whisper"),
				Localization.instance.Localize("/s [text] - $chat_shout"),
				Localization.instance.Localize("/die - $chat_kill"),
				Localization.instance.Localize("/resetspawn - $chat_resetspawn"),
				Localization.instance.Localize("/[emote]"),
				Localization.instance.Localize(text),
				""
			};
			if (ChatBufferField == null || TerminalUpdateChatMethod == null)
			{
				ClanPlugin.ClanLogger.LogWarning((object)"Vanilla startup chat help could not be removed because the chat buffer API was not found.");
				return;
			}
			if (!(ChatBufferField.GetValue(chat) is List<string> list))
			{
				ClanPlugin.ClanLogger.LogWarning((object)"Vanilla startup chat help could not be removed because the chat buffer was unavailable.");
				return;
			}
			EnsureTrackedChat((Terminal)(object)chat);
			EnsureChatHistoryAligned(list);
			for (int num = 0; num <= list.Count - array.Length; num++)
			{
				bool flag = true;
				for (int num2 = 0; num2 < array.Length; num2++)
				{
					if (!string.Equals(list[num + num2], array[num2], StringComparison.Ordinal))
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					list.RemoveRange(num, array.Length);
					ChatLineKinds.RemoveRange(num, array.Length);
					TerminalUpdateChatMethod.Invoke(chat, null);
					break;
				}
			}
		}

		private static void AppendEmojiToken(int emojiIndex)
		{
			if (!ClanEmoji.IsReady || emojiIndex < 0 || emojiIndex >= ClanEmoji.EmojiCount)
			{
				return;
			}
			TMP_InputField inputField = GetInputField();
			if ((Object)(object)inputField == (Object)null)
			{
				return;
			}
			string text = ClanEmoji.TokenFor(emojiIndex);
			if (string.IsNullOrWhiteSpace(text))
			{
				return;
			}
			string text2 = text + " ";
			if (ClanEmoji.CountMessageEmojiTokens(inputField.text) >= ClanEmoji.MessageEmojiLimit)
			{
				ClanRpc.NotifyStatus(ClanLocalization.Format("chat_emoji_limit", ClanEmoji.MessageEmojiLimit));
				return;
			}
			int num = 400;
			if (inputField.characterLimit > 0)
			{
				num = Math.Min(num, inputField.characterLimit);
			}
			if (inputField.text.Length > num - text2.Length)
			{
				ClanRpc.NotifyStatus(ClanLocalization.Format("chat_character_limit", num));
			}
			else
			{
				inputField.text += text2;
				MoveCaretToEnd(inputField);
			}
		}

		internal static bool HasFocusedChatInputForHud()
		{
			TMP_InputField inputField = GetInputField();
			if ((Object)(object)inputField != (Object)null && IsChatInputOpen(inputField))
			{
				return inputField.isFocused;
			}
			return false;
		}

		internal static void RestoreChatInputAfterHudInteraction()
		{
			RefocusChatInput();
		}

		private static void RefocusChatInput()
		{
			TMP_InputField inputField = GetInputField();
			if (!((Object)(object)inputField == (Object)null) && ((Component)inputField).gameObject.activeInHierarchy)
			{
				FocusChatInputAtEnd(inputField);
			}
		}

		private static void ScheduleChatRefocus(Chat chat)
		{
			_chatRefocusOwner = chat;
			_chatRefocusFrame = Time.frameCount + 1;
			_chatRefocusDeadlineFrame = Time.frameCount + 4;
		}

		private static void CancelPendingChatRefocus()
		{
			_chatRefocusOwner = null;
			_chatRefocusFrame = -1;
			_chatRefocusDeadlineFrame = -1;
		}

		private static bool HasPendingChatRefocus(Chat chat)
		{
			if (ClanPlugin.ChatAfterSend.Value == ClanPlugin.ChatSubmitMode.KeepOpen && _chatRefocusFrame >= 0)
			{
				return _chatRefocusOwner == chat;
			}
			return false;
		}

		private static void ApplyPendingChatRefocus(TMP_InputField input)
		{
			if (_chatRefocusFrame < 0 || Time.frameCount < _chatRefocusFrame)
			{
				return;
			}
			if (ClanPlugin.ChatAfterSend.Value != ClanPlugin.ChatSubmitMode.KeepOpen)
			{
				CancelPendingChatRefocus();
				return;
			}
			Chat chatRefocusOwner = _chatRefocusOwner;
			if ((Object)(object)chatRefocusOwner == (Object)null || (Object)(object)Chat.instance != (Object)(object)chatRefocusOwner || ClanPanelController.OwnsSelectedControl || ZInput.GetKeyDown((KeyCode)27, true) || ZInput.GetButtonDown("JoyButtonB") || IsBlockingModalVisible())
			{
				CancelPendingChatRefocus();
			}
			else if (!((Behaviour)input).enabled || !((Selectable)input).interactable)
			{
				CancelPendingChatRefocus();
			}
			else if (input.isFocused)
			{
				MoveCaretToEnd(input);
				CancelPendingChatRefocus();
			}
			else if (_chatRefocusDeadlineFrame >= 0 && Time.frameCount > _chatRefocusDeadlineFrame)
			{
				CancelPendingChatRefocus();
			}
			else
			{
				EnsureChatVisible(chatRefocusOwner, input);
				FocusChatInputAtEnd(input);
				_chatRefocusFrame = Time.frameCount + 1;
			}
		}

		private static void EnsureChatVisible(Chat chat, TMP_InputField input)
		{
			ResetChatHideTimer(chat);
			RectTransform chatWindow = ((Terminal)chat).m_chatWindow;
			if ((Object)(object)chatWindow != (Object)null && !((Component)chatWindow).gameObject.activeSelf)
			{
				((Component)chatWindow).gameObject.SetActive(true);
			}
			if (!((Component)input).gameObject.activeSelf)
			{
				((Component)input).gameObject.SetActive(true);
			}
		}

		private static FieldRef<Chat, float>? CreateChatHideTimerAccessor()
		{
			try
			{
				return AccessTools.FieldRefAccess<Chat, float>("m_hideTimer");
			}
			catch (Exception ex)
			{
				ClanPlugin.ClanLogger.LogWarning((object)("Vanilla chat visibility integration is unavailable: " + ex.Message));
				return null;
			}
		}

		private static void ResetChatHideTimer(Chat chat)
		{
			FieldRef<Chat, float> chatHideTimer = _chatHideTimer;
			if (chatHideTimer == null)
			{
				return;
			}
			try
			{
				chatHideTimer.Invoke(chat) = 0f;
			}
			catch (Exception ex)
			{
				_chatHideTimer = null;
				ClanPlugin.ClanLogger.LogWarning((object)("Vanilla chat visibility integration was disabled: " + ex.Message));
			}
		}

		private static void FocusChatInputAtEnd(TMP_InputField input)
		{
			input.ActivateInputField();
			EventSystem current = EventSystem.current;
			if (current != null)
			{
				current.SetSelectedGameObject(((Component)input).gameObject);
			}
			MoveCaretToEnd(input);
		}

		private static void MoveCaretToEnd(TMP_InputField input)
		{
			input.caretPosition = input.text.Length;
			input.selectionAnchorPosition = input.text.Length;
			input.selectionFocusPosition = input.text.Length;
			input.MoveTextEnd(false);
		}

		private static void SetButtonColor(Button? button, Color color, Color labelColor)
		{
			//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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)button == (Object)null))
			{
				Graphic targetGraphic = ((Selectable)button).targetGraphic;
				Image val = (Image)(object)((targetGraphic is Image) ? targetGraphic : null);
				if (val != null)
				{
					((Graphic)val).color = Color.white;
				}
				ColorBlock colors = ((Selectable)button).colors;
				((ColorBlock)(ref colors)).normalColor = color;
				((ColorBlock)(ref colors)).highlightedColor = Color.Lerp(color, ButtonHoverColor, 0.16f);
				((ColorBlock)(ref colors)).pressedColor = new Color(color.r * 0.72f, color.g * 0.72f, color.b * 0.72f, color.a);
				((ColorBlock)(ref colors)).selectedColor = color;
				((ColorBlock)(ref colors)).disabledColor = color;
				((ColorBlock)(ref colors)).colorMultiplier = 1f;
				((ColorBlock)(ref colors)).fadeDuration = 0.1f;
				((Selectable)button).colors = colors;
				SetButtonLabelColor(button, labelColor);
			}
		}

		private static void SetButtonLabelColor(Button button, Color color)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Text[] componentsInChildren = ((Component)button).GetComponentsInChildren<Text>(true);
			foreach (Text val in componentsInChildren)
			{
				if ((Object)(object)((Component)val).transform.parent == (Object)(object)((Component)button).transform)
				{
					((Graphic)val).color = color;
				}
			}
		}

		private static void AddPreferredHeight(GameObject gameObject, float height)
		{
			LayoutElement obj = gameObject.GetComponent<LayoutElement>() ?? gameObject.AddComponent<LayoutElement>();
			obj.preferredHeight = height;
			obj.minHeight = height;
		}

		private static void TryApplyButtonStyle(Button button)
		{
			try
			{
				GUIManager.Instance.ApplyButtonStyle(button, 12);
			}
			catch (Exception)
			{
			}
		}
	}
	[BepInPlugin("sighsorry.Clan", "Clan", "1.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInIncompatibility("org.bepinex.plugins.groups")]
	[BepInIncompatibility("org.bepinex.plugins.guilds")]
	public sealed class ClanPlugin : BaseUnityPlugin
	{
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		public enum ChatSubmitMode
		{
			CloseAfterSend,
			KeepOpen
		}

		private sealed class ConfigurationManagerAttributes
		{
			public int? Order;

			public bool? Browsable;
		}

		public const string ModName = "Clan";

		public const string ModVersion = "1.0.1";

		public const string Author = "sighsorry";

		public const string ModGUID = "sighsorry.Clan";

		internal static ConfigEntry<Toggle> ServerConfigLocked = null;

		internal static ConfigEntry<KeyboardShortcut> ClanPingModifierKey = null;

		internal static ConfigEntry<Toggle> ShareClanPositions = null;

		internal static ConfigEntry<Toggle> ClanFriendlyFire = null;

		internal static ConfigEntry<float> ClanChatWindowScale = null;

		internal static ConfigEntry<KeyboardShortcut> ClanPanelShortcut = null;

		internal static ConfigEntry<KeyboardShortcut> EmojiPanelShortcut = null;

		internal static ConfigEntry<Toggle> ShowWhisperChatButton = null;

		internal static ConfigEntry<Toggle> ShowResetSpawnButton = null;

		internal static ConfigEntry<Toggle> ShowDieButton = null;

		internal static ConfigEntry<ChatSubmitMode> ChatAfterSend = null;

		internal static ConfigEntry<Toggle> ShowClanHud = null;

		internal static ConfigEntry<Toggle> ClanHudPlayerListCollapsed = null;

		internal static ConfigEntry<Vector2> ClanHudPosition = null;

		private static readonly ConfigSync ConfigSync = new ConfigSync("sighsorry.Clan")
		{
			DisplayName = "Clan",
			CurrentVersion = "1.0.1",
			MinimumRequiredVersion = "1.0.1"
		};

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

		private static readonly string ConfigFileFullPath;

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

		private readonly object _reloadLock = new object();

		private FileSystemWatcher? _watcher;

		private DateTime _lastConfigReloadTime;

		private const long ReloadDelayTicks = 10000000L;

		internal static ManualLogSource ClanLogger { get; } = Logger.CreateLogSource("Clan");

		internal static string DataDirectory => Path.Combine(Utils.GetSaveDataPath((FileSource)1), "Clan");

		internal static string MediaDirectory => Path.Combine(Paths.ConfigPath, "Clan");

		private void Awake()
		{
			ClanLocalization.Initialize((BaseUnityPlugin)(object)this, _harmony);
			BindConfiguration();
			ClanEmoji.Init();
			ClanRegistry.Init();
			ClanRecentPlayers.Init();
			ClanApi.Initialize();
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			ClanVanillaChatDock.Init();
			ClanHud.Init();
			SetupWatcher();
			ClanLogger.LogInfo((object)"Clan 1.0.1 loaded with Jotunn dependency com.jotunn.jotunn.");
		}

		private void BindConfiguration()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00f1: 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_0121: Expected O, but got Unknown
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Expected O, but got Unknown
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
			try
			{
				((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
				ServerConfigLocked = ConfigEntry("1 - General", "Lock Configuration", Toggle.On, new ConfigDescription("If on, only server admins can change synced configuration.", (AcceptableValueBase)null, new object[1]
				{
					new ConfigurationManagerAttributes
					{
						Order = 4
					}
				}));
				ConfigSync.AddLockingConfigEntry<Toggle>(ServerConfigLocked);
				ClanFriendlyFire = ConfigEntry("1 - General", "Clan Friendly Fire", Toggle.On, new ConfigDescription("If on, clan-connected players can damage each other.", (AcceptableValueBase)null, new object[1]
				{
					new ConfigurationManagerAttributes
					{
						Order = 3
					}
				}));
				ShareClanPositions = ConfigEntry("1 - General", "Share Clan Positions", Toggle.On, new ConfigDescription("If on, clan members and guests can share position visibility.", (AcceptableValueBase)null, new object[1]
				{
					new ConfigurationManagerAttributes
					{
						Order = 2
					}
				}));
				ClanPingModifierKey = ConfigEntry<KeyboardShortcut>("1 - General", "Clan Ping Modifier Key", new KeyboardShortcut((KeyCode)304, Array.Empty<KeyCode>()), new ConfigDescription("Modifier key reserved for clan-only pings.", (AcceptableValueBase)null, new object[1]
				{
					new ConfigurationManagerAttributes
					{
						Order = 1
					}
				}), synchronizedSetting: false);
				ClanChatWindowScale = ConfigEntry("2 - UI", "Clan Chat Window Scale", 2f, new ConfigDescription("Uniform scale for the vanilla chat window, including text and inline emojis. The upper-left resize handle updates this value.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 2f), Array.Empty<object>()), synchronizedSetting: false);
				ClanPanelShortcut = ConfigEntry<KeyboardShortcut>("2 - UI", "Clan Panel Shortcut", new KeyboardShortcut((KeyCode)104, Array.Empty<KeyCode>()), "Client-only shortcut that opens or closes the Clan panel. Set the main key to None to disable it.", synchronizedSetting: false);
				EmojiPanelShortcut = ConfigEntry<KeyboardShortcut>("2 - UI", "Emoji Panel Shortcut", new KeyboardShortcut((KeyCode)103, Array.Empty<KeyCode>()), "Client-only shortcut that opens the chat and Emoji panel. Set the main key to None to disable it.", synchronizedSetting: false);
				ShowWhisperChatButton = ConfigEntry("2 - UI", "Show Whisper Chat Button", Toggle.Off, "If on, shows the optional Whisper channel button below the chat panel.", synchronizedSetting: false);
				ShowResetSpawnButton = ConfigEntry("2 - UI", "Show Reset Spawn Button", Toggle.Off, "If on, shows the Reset spawn command button at the lower-right of the chat panel.", synchronizedSetting: false);
				ShowDieButton = ConfigEntry("2 - UI", "Show Die Button", Toggle.On, "If on, shows the Die command button at the lower-right of the chat panel.", synchronizedSetting: false);
				ChatAfterSend = ConfigEntry("2 - UI", "Chat After Send", ChatSubmitMode.KeepOpen, "Controls the chat input after sending a message. CloseAfterSend restores Valheim's default behavior; KeepOpen immediately focuses the chat input again.", synchronizedSetting: false);
				ShowClanHud = ConfigEntry("2 - UI", "Show Clan Member HUD", Toggle.On, "If on, shows a compact clan member HUD.", synchronizedSetting: false);
				ClanHudPlayerListCollapsed = ConfigEntry("2 - UI", "Clan HUD Player List Collapsed", Toggle.Off, new ConfigDescription("Stores whether the Clan HUD player list is collapsed.", (AcceptableValueBase)null, new object[1]
				{
					new ConfigurationManagerAttributes
					{
						Browsable = false
					}
				}), synchronizedSetting: false);
				ClanHudPosition = ConfigEntry<Vector2>("2 - UI", "Clan HUD Position", new Vector2(0.015f, 0.32f), "Normalized safe-area position of the Clan HUD's upper-left corner. Drag the Clan header to update it.", synchronizedSetting: false);
				((BaseUnityPlugin)this).Config.Save();
			}
			finally
			{
				((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
			}
		}

		private void OnDestroy()
		{
			DisposeWatcher();
			TryShutdown(delegate
			{
				SaveWithRespectToConfigSet();
			}, "save configuration");
			TryShutdown(ClanVanillaChatDock.Dispose, "dispose chat dock");
			TryShutdown(ClanHud.Dispose, "dispose HUD");
			TryShutdown(ClanUiFeedback.Dispose, "dispose UI feedback");
			TryShutdown(ClanApi.Dispose, "dispose API");
			TryShutdown(ClanRecentPlayers.Dispose, "dispose recent-player storage");
			TryShutdown(ClanEmoji.Dispose, "dispose media runtime");
			TryShutdown(ClanMap.ResetSession, "reset map state");
			TryShutdown(ClanLocalization.Dispose, "dispose localization runtime");
			TryShutdown((Action)_harmony.UnpatchSelf, "remove Harmony patches");
		}

		private void DisposeWatcher()
		{
			FileSystemWatcher watcher = _watcher;
			_watcher = null;
			if (watcher != null)
			{
				TryShutdown(delegate
				{
					watcher.EnableRaisingEvents = false;
				}, "stop configuration watcher");
				TryShutdown(watcher.Dispose, "dispose configuration watcher");
			}
		}

		private static void TryShutdown(Action action, string operation)
		{
			try
			{
				action();
			}
			catch (Exception ex)
			{
				ClanLogger.LogWarning((object)("Failed to " + operation + " during shutdown: " + ex.Message));
			}
		}

		private void Update()
		{
			ClanEmoji.Tick();
			ClanRpc.Tick();
			ClanApi.Tick();
			ClanRecentPlayers.Tick();
			ClanVanillaChatDock.Tick();
			ClanHud.Tick();
			ClanMap.Tick();
		}

		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))
				{
					ClanLogger.LogWarning((object)"Config file does not exist. Skipping reload.");
					return;
				}
				try
				{
					SaveWithRespectToConfigSet(reload: true);
					ClanLogger.LogInfo((object)"Configuration reload complete.");
				}
				catch (Exception ex)
				{
					ClanLogger.LogError((object)("Error reloading configuration: " + ex.Message));
				}
			}
			_lastConfigReloadTime = now;
		}

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

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

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

		static ClanPlugin()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
		}
	}
	internal static class ClanKeyboardExtensions
	{
		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;
		}
	}
	internal static class ClanToggleExtensions
	{
		public static bool IsOn(this ClanPlugin.Toggle value)
		{
			return value == ClanPlugin.Toggle.On;
		}
	}
}
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;
		}
	}
}