using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Peak.Network;
using Photon.Pun;
using Photon.Realtime;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("BetterPlayerDistance")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("High Performance Distance Display")]
[assembly: AssemblyFileVersion("1.1.3.0")]
[assembly: AssemblyInformationalVersion("1.1.3+ccaa48cec9a3d341f4b78d9d33a0751782fc9027")]
[assembly: AssemblyProduct("BetterPlayerDistance")]
[assembly: AssemblyTitle("BetterPlayerDistance")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BetterPlayerDistance
{
	public enum TriggerModeEnum
	{
		Toggle,
		Hold,
		AlwaysOn
	}
	public enum DownedDisplayEnum
	{
		IconBigDroop,
		IconWavy,
		IconDownCurl,
		IconSmallDroop,
		IconFlat,
		KaomojiClassic,
		KaomojiFrown,
		KaomojiFlat,
		KaomojiSquiggle,
		KaomojiArch,
		Text
	}
	public enum DeadDisplayEnum
	{
		IconBigDroop,
		IconWavy,
		IconFlat,
		KaomojiClassic,
		KaomojiFrown,
		KaomojiSquiggle,
		KaomojiArch,
		Text
	}
	public enum EdgeTextModeEnum
	{
		None,
		Name,
		Percent,
		NamePercent
	}
	public static class Configuration
	{
		public static ConfigEntry<bool> ShowDistance;

		public static ConfigEntry<bool> ShowDistanceUpClose;

		public static ConfigEntry<bool> CompatibilityMode;

		public static ConfigEntry<KeyCode> ToggleKey;

		public static ConfigEntry<TriggerModeEnum> TriggerMode;

		public static ConfigEntry<float> ToggleDuration;

		public static ConfigEntry<float> HoldKeepDuration;

		public static ConfigEntry<float> MaxDistance;

		public static ConfigEntry<float> NameFontSizeOffset;

		public static ConfigEntry<float> DistFontSize;

		public static ConfigEntry<float> NameDistanceHeight;

		public static ConfigEntry<float> GlobalOpacity;

		public static ConfigEntry<float> NameShadowOpacity;

		public static ConfigEntry<float> LineGap;

		public static ConfigEntry<bool> FollowTimeTheme;

		public static ConfigEntry<NightOutlineEnum> NightOutline;

		public static ConfigEntry<float> HostCrownGap;

		public static ConfigEntry<float> HostCrownOffsetY;

		public const float DefaultHostCrownGap = -4.4f;

		public const float DefaultHostCrownOffsetY = 0.9f;

		public const float HostCrownSizeRatio = 0.95f;

		public const float LineSpacingPercent = 8f;

		public const float VanillaDistSizeRatio = 0.85f;

		public static ConfigEntry<bool> EnableDownedLabel;

		public static ConfigEntry<DownedDisplayEnum> DownedDisplay;

		public static ConfigEntry<DeadDisplayEnum> DeadDisplay;

		public static ConfigEntry<bool> DownedTextPlayerColor;

		public static ConfigEntry<bool> DownedTextOutlinePlayerColor;

		public static ConfigEntry<bool> EnableDownedEdgeIndicator;

		public static ConfigEntry<EdgeTextModeEnum> DownedEdgeText;

		public static ConfigEntry<float> DownedFontSize;

		public static ConfigEntry<float> DownedIconSize;

		public static ConfigEntry<float> DownedEdgeIconSize;

		public static ConfigEntry<float> DownedRingWidth;

		public static ConfigEntry<float> DownedNearNameGap;

		public const float FixedShadowAlpha = 0.8f;

		public const float FixedDownedEdgeMargin = 60f;

		public const float FixedDownedBreathPeriod = 1.5f;

		public const float FixedDownedBreathMinAlpha = 0.6f;

		public const float FixedDownedDeadMarkerDuration = 10f;

		public const bool FixedHighQuality = false;

		public const float ShadowSpreadRatio = 3f / 32f;

		public static ConfigEntry<bool> DebugMode;

		public static ConfigEntry<KeyCode> DebugMenuKey;

		public static ConfigEntry<bool> DisableTMPWarnings;

		private const string CAT_BASIC = "1. 基础 (Basic)";

		private const string CAT_UI = "2. 界面 (UI)";

		private const string CAT_DEBUG = "4. 调试 (Debug)";

		public static bool IsCompatibilityMode
		{
			get
			{
				if (CompatibilityMode != null)
				{
					return CompatibilityMode.Value;
				}
				return false;
			}
		}

		public static string DownedWord
		{
			get
			{
				if (!IsChineseUI())
				{
					return "Downed";
				}
				return "昏迷";
			}
		}

		public static string DeadWord
		{
			get
			{
				if (!IsChineseUI())
				{
					return "Dead";
				}
				return "死亡";
			}
		}

		public static Color FixedShadowColor => ThemeBridge.OutlineColor;

		public static Color MainTextColor => ThemeBridge.MainTextColor;

		public static float ResolveHostCrownGap()
		{
			if (HostCrownGap == null)
			{
				return -4.4f;
			}
			return HostCrownGap.Value;
		}

		public static float ResolveHostCrownOffsetY()
		{
			if (HostCrownOffsetY == null)
			{
				return 0.9f;
			}
			return HostCrownOffsetY.Value;
		}

		public static float ResolveLineSpacing()
		{
			if (LineGap == null)
			{
				return 8f;
			}
			return LineGap.Value;
		}

		public static float ApplyNameFontSizeOffset(float originalSize)
		{
			float num = ((NameFontSizeOffset != null) ? NameFontSizeOffset.Value : 0f);
			return Mathf.Max(1f, originalSize + num);
		}

		public static float ResolveNameFontSize(float vanillaPixelSize, float canvasScale, float vanillaScale = 1f)
		{
			if (vanillaPixelSize <= 0f || canvasScale <= 0.0001f || vanillaScale <= 0.0001f)
			{
				return ApplyNameFontSizeOffset(16f);
			}
			return ApplyNameFontSizeOffset(vanillaPixelSize / vanillaScale) * vanillaScale / canvasScale;
		}

		public static float ResolveDistFontSize(float nameSize)
		{
			float num = ((DistFontSize != null) ? DistFontSize.Value : 0f);
			return Mathf.Max(1f, nameSize * 0.85f + num);
		}

		public static float ResolveNameDistanceHeight(float uiScale)
		{
			return ((NameDistanceHeight != null) ? NameDistanceHeight.Value : 0f) * ((uiScale > 0.0001f) ? uiScale : 1f);
		}

		public static bool IsIconDisplay(bool dead)
		{
			if (!dead)
			{
				return DownedDisplay.Value <= DownedDisplayEnum.IconFlat;
			}
			return DeadDisplay.Value <= DeadDisplayEnum.IconFlat;
		}

		public static int GetIconIndex(bool dead)
		{
			if (!dead)
			{
				return (int)DownedDisplay.Value;
			}
			return (int)DeadDisplay.Value;
		}

		private static bool IsChineseUI()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if ((int)LocalizedText.CURRENT_LANGUAGE != 9)
			{
				return (int)LocalizedText.CURRENT_LANGUAGE == 10;
			}
			return true;
		}

		public static string GetStatusText(bool dead)
		{
			if (dead)
			{
				return DeadDisplay.Value switch
				{
					DeadDisplayEnum.KaomojiClassic => "(×_×)", 
					DeadDisplayEnum.KaomojiFrown => "(×︵×)", 
					DeadDisplayEnum.KaomojiSquiggle => "(×\ufe4f×)", 
					DeadDisplayEnum.KaomojiArch => "(×︿×)", 
					_ => DeadWord, 
				};
			}
			return DownedDisplay.Value switch
			{
				DownedDisplayEnum.KaomojiClassic => "(@_@')", 
				DownedDisplayEnum.KaomojiFrown => "(@︵@)", 
				DownedDisplayEnum.KaomojiFlat => "(@\uff3f@)", 
				DownedDisplayEnum.KaomojiSquiggle => "(@\ufe4f@)", 
				DownedDisplayEnum.KaomojiArch => "(@︿@)", 
				_ => DownedWord, 
			};
		}

		public static float ShadowSpread(float fontSize)
		{
			return fontSize * (3f / 32f);
		}

		public static Color ToOutlineColor(Color playerColor)
		{
			//IL_0000: 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)
			float num = default(float);
			float num2 = default(float);
			float num3 = default(float);
			Color.RGBToHSV(playerColor, ref num, ref num2, ref num3);
			return Color.HSVToRGB(num, num2, Mathf.Min(num3, 0.45f));
		}

		public static void Initialize(ConfigFile config)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Expected O, but got Unknown
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Expected O, but got Unknown
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Expected O, but got Unknown
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Expected O, but got Unknown
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Expected O, but got Unknown
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Expected O, but got Unknown
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Expected O, but got Unknown
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Expected O, but got Unknown
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Expected O, but got Unknown
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Expected O, but got Unknown
			if (File.Exists(config.ConfigFilePath))
			{
				string text = File.ReadAllText(config.ConfigFilePath);
				string text2 = ConfigurationMigration.UpgradeText(text);
				if (text2 != text)
				{
					File.WriteAllText(config.ConfigFilePath, text2, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
					config.Reload();
				}
			}
			ToggleKey = config.Bind<KeyCode>("1. 基础 (Basic)", "快捷键 (Hotkey)", (KeyCode)99, "显示/隐藏玩家标签的按键；Hold/Toggle/AlwaysOn 三种模式均可用。\nHotkey to show/hide player labels; works in all three modes (Hold/Toggle/AlwaysOn).");
			TriggerMode = config.Bind<TriggerModeEnum>("1. 基础 (Basic)", "显示模式 (Display Mode)", TriggerModeEnum.AlwaysOn, new ConfigDescription("Hold=按住显示；Toggle=切换开关；AlwaysOn=常显（默认全程显示，可按快捷键手动隐藏/恢复）。\nHold = press to show; Toggle = press to switch; AlwaysOn = always-on by default, hotkey toggles a user-hide flag.", (AcceptableValueBase)null, Array.Empty<object>()));
			ToggleDuration = config.Bind<float>("1. 基础 (Basic)", "切换显示时长 (Toggle Duration)", 10f, new ConfigDescription("Toggle 模式下按一次后保持显示的秒数。\nHow many seconds labels stay visible after a single press in Toggle mode.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 9999f), Array.Empty<object>()));
			HoldKeepDuration = config.Bind<float>("1. 基础 (Basic)", "松手保持时长 (Hold Release Linger)", 1f, new ConfigDescription("Hold 模式下松开按键后继续显示的秒数。\nHow many extra seconds labels linger after the key is released in Hold mode.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			ShowDistanceUpClose = config.Bind<bool>("1. 基础 (Basic)", "贴近是否显示距离 (Show Distance Up Close)", false, "游戏原版此刻应显示名称时，是否同时显示距离。关闭时仅隐藏距离，名称和皇冠仍显示；其他情况下照常显示距离。\n开启时不再套用这条近处隐藏规则，全程显示距离。快捷键仍控制整块标签。\nShow distance when the vanilla game would currently show the name. Off hides only the distance; the name and crown remain visible.\nIn every other case distance remains visible. On disables this close-range hiding rule. The hotkey still controls the entire label.");
			CompatibilityMode = config.Bind<bool>("1. 基础 (Basic)", "兼容模式 (Compatibility Mode)", false, "开启后不再隐藏游戏原版的头顶名称：原版按自己的距离与视角规则显示名称时，本模组的名称与距离标签整块让位；\n原版隐藏时本模组接上，两边 0.1 秒交叉渐变。「名字字号」会同步套到原版名称与房主皇冠上，切换时大小一致。\n供依赖原版头顶名称的模组使用（例如头顶耐力 Overhead Stamina）。开启时，原版名称显示期间不显示距离。\nStops hiding the vanilla overhead name. While vanilla shows a name by its own distance and angle rules,\nthis mod's label yields entirely; when vanilla hides it, this mod takes over with a 0.1s cross-fade.\nName Font Size is also applied to the vanilla name and host crown so both match.\nFor mods that depend on the vanilla nameplate (e.g. Overhead Stamina). Distance is hidden while the vanilla name is shown.");
			ShowDistance = config.Bind<bool>("2. 界面 (UI)", "显示距离 (Show Distance)", true, "是否显示距离数值。\nWhether to display the distance number.");
			MaxDistance = config.Bind<float>("2. 界面 (UI)", "最大显示距离 (Max Display Distance)", 1000f, new ConfigDescription("超过此距离不显示(米)。\nPlayers farther than this distance are hidden (meters).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(50f, 1500f), Array.Empty<object>()));
			NameFontSizeOffset = config.Bind<float>("2. 界面 (UI)", "名字字号 (Name Font Size)", 0f, new ConfigDescription("在原版基础字号上增减。0 = 原始大小；+1 = 原始字号加 1；-1 = 原始字号减 1，最小为 1。\n近远距离使用同一份名称，并自动换算界面缩放。皇冠按字号比例缩放，位置跟随名字。\nName font size offset from the original vanilla size: 0 = unchanged, +1 = one larger, -1 = one smaller (minimum 1).\nThe same name is used at all ranges. Crowns scale and stay aligned with the name.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-20f, 20f), Array.Empty<object>()));
			DistFontSize = config.Bind<float>("2. 界面 (UI)", "距离字号 (Distance Font Size)", 0f, new ConfigDescription($"距离字号偏移量。0 = 名字字号的 {0.85f:P0}；+1 = 在这个基准上加 1；-1 = 减 1，最小为 1。\n" + $"Distance font size offset. 0 = {0.85f:P0} of the name size; +1 adds one, -1 subtracts one (minimum 1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-20f, 20f), Array.Empty<object>()));
			NameDistanceHeight = config.Bind<float>("2. 界面 (UI)", "名称与距离高度 (Name & Distance Height)", 0f, new ConfigDescription("名称、距离和皇冠一起上下移动。0 = 原位置，正数上移，负数下移；不改变距离读数。\n单位为 1080p 基准下的界面像素，随界面缩放；关联的昏迷标签会跟随，保持间距。\nMove the name, distance and crown together: 0 = original position, positive = up, negative = down.\nUses UI pixels at the 1080p reference scale. Related downed labels follow to preserve spacing.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-100f, 100f), Array.Empty<object>()));
			GlobalOpacity = config.Bind<float>("2. 界面 (UI)", "整体透明度 (Global Opacity)", 1f, new ConfigDescription("整体不透明度 (0-1)。默认 1，与原版名称一致。\nOverall opacity (0-1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			NameShadowOpacity = config.Bind<float>("2. 界面 (UI)", "描边与阴影透明度 (Outline-Shadow Opacity)", 1f, new ConfigDescription("名称和距离的描边、阴影浓度。1 保留原版浓度，0 隐藏描边与阴影。\n不改变文字本身的透明度；整体透明度仍会同时影响文字与阴影。\nName/distance outline and shadow opacity. 1 = original strength; 0 = hidden. Leaves the glyph fill unchanged.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			LineGap = config.Bind<float>("2. 界面 (UI)", "名字与距离行距 (Name-Distance Line Gap)", 8f, new ConfigDescription("名字行与距离行之间的额外间距。0 = TMP 默认行距，默认 8 只比默认松一点点。\n注意单位是 TMP 基础字号(36)的百分比，不是名字字号的百分比。\nExtra gap between the name line and the distance line.\n0 = TMP default line spacing; 8 = just a touch looser than default.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>()));
			FollowTimeTheme = config.Bind<bool>("2. 界面 (UI)", "跟随 TimeTheme 改变字体颜色 (Follow TimeTheme Colors)", true, "装了 TimeTheme 模组时，夜晚把字体与描边过渡到它的夜间配色（0.25 秒，与它同步），\n白天恢复原版暖白。未安装 TimeTheme 时本项无效果。\nWith the TimeTheme mod installed, shifts the glyph and outline colors to its night\npalette at night (0.25s, in sync with it) and back to the vanilla warm white by day.\nNo effect when TimeTheme is not installed.");
			NightOutline = config.Bind<NightOutlineEnum>("2. 界面 (UI)", "夜间描边颜色 (Night Outline Color)", NightOutlineEnum.FollowVanilla, new ConfigDescription("FollowVanilla（默认）：描边与游戏原版名称一致，安装 TimeTheme 时字色也跟随原版。\n其余为玩家自定义夜间描边色：DeepPurple=深紫；DarkBlueViolet=深蓝紫；\nUnchanged=暗橄榄。自定义色仅在开启 TimeTheme 跟随时生效。\nFollowVanilla (default) matches the game's name style. Other values customize the night outline.", (AcceptableValueBase)null, Array.Empty<object>()));
			DownedConfiguration.Initialize(config);
			DebugMode = config.Bind<bool>("4. 调试 (Debug)", "启用调试工具 (Enable Debug Tools)", false, "同时控制两件事：能否用 Insert 呼出调试控制台，以及本模组往 BepInEx 控制台\n输出多少日志。关闭时只会打一行加载信息（异常和降级警告仍会照常输出）。\nControls both the Insert debug console and how much this mod logs.\nWhen off, only a single load line is printed (errors and warnings still show).");
			DebugMenuKey = config.Bind<KeyCode>("4. 调试 (Debug)", "调试菜单键 (Debug Menu Key)", (KeyCode)277, "打开调试控制台的按键。\nKey used to open the debug console.");
			DisableTMPWarnings = config.Bind<bool>("4. 调试 (Debug)", "禁用全局TMP缺字警告 (Disable TMP Missing-Glyph Warnings)", true, "开启后将禁止 TextMeshPro 向控制台输出缺字警告，可显著解决特殊字符导致的掉帧问题（开发者请关闭）。\nWhen on, suppresses TextMeshPro missing-glyph warnings to avoid console spam and frame drops (developers should disable this).");
			HostCrownGap = config.Bind<float>("4. 调试 (Debug)", "皇冠与名字间距 (Crown-Name Gap)", -4.4f, new ConfigDescription("房主皇冠右边缘到名字可见字形左边缘的距离。调大向左远离名字，调小贴近，负数允许重叠。\n单位是未加字号偏移时的名字局部坐标，随字号和界面缩放等比变化。\n近、远距离皇冠共用此位置；不移动名字与距离，修改后下一帧生效。\nGap from the host crown's right edge to the left edge of the name's visible glyphs, in the name\ntext's original local units, scaling with the name size. Larger = farther left; negative = overlap.\nThe crown uses this placement at all ranges. Names and distances are not moved; applies on the next frame.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-20f, 60f), Array.Empty<object>()));
			HostCrownOffsetY = config.Bind<float>("4. 调试 (Debug)", "皇冠上下偏移 (Crown Vertical Offset)", 0.9f, new ConfigDescription("房主皇冠相对名字可见字形垂直中心的上下偏移。正数上移，负数下移，随字号等比变化，单位同上一项。\n近、远距离皇冠共用此位置；不移动名字与距离，修改后下一帧生效。\nVertical offset of the host crown from the visible name's center, same units as the gap above.\nPositive = up; negative = down. The crown uses this placement at all ranges.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-40f, 40f), Array.Empty<object>()));
		}
	}
	internal static class ConfigurationMigration
	{
		private const string BasicSection = "[1. 基础 (Basic)]";

		private const string UiSection = "[2. 界面 (UI)]";

		private const string DownedSection = "[3. 昏迷指向 (Downed Pointer)]";

		private const string VanillaNameKey = "原版名字处理方式 (Vanilla Name Mode)";

		private const string CloseDistanceKey = "贴近是否显示距离 (Show Distance Up Close)";

		private static readonly Dictionary<string, string> UiKeyRenames = new Dictionary<string, string>
		{
			{ "名字字号 (Name Font Size, 0 跟随原版)", "名字字号 (Name Font Size)" },
			{ "名字字号偏移量 (Name Font Size Offset)", "名字字号 (Name Font Size)" },
			{ "距离字号 (Distance Font Size, 0 跟随原版)", "距离字号 (Distance Font Size)" }
		};

		public static string UpgradeText(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return text;
			}
			List<string> list = new List<string>();
			foreach (Match item in Regex.Matches(text, "[^\\r\\n]*(?:\\r\\n|\\n|\\r|$)"))
			{
				if (item.Length > 0)
				{
					list.Add(item.Value);
				}
			}
			bool[] array = new bool[list.Count];
			List<string> list2 = null;
			int num = -1;
			bool flag = false;
			bool flag2 = false;
			string text2 = string.Empty;
			string text3 = Regex.Match(text, "\\r\\n|\\n|\\r").Value;
			if (text3.Length == 0)
			{
				text3 = Environment.NewLine;
			}
			HashSet<string> hashSet = new HashSet<string>();
			foreach (string item2 in list)
			{
				string text4 = item2.Trim();
				if (text4.StartsWith("[", StringComparison.Ordinal) && text4.EndsWith("]", StringComparison.Ordinal))
				{
					text2 = text4;
				}
				int num2 = text4.IndexOf('=');
				if (text2 == "[2. 界面 (UI)]" && num2 >= 0 && !IsComment(text4))
				{
					hashSet.Add(text4.Substring(0, num2).Trim());
				}
			}
			text2 = string.Empty;
			for (int i = 0; i < list.Count; i++)
			{
				string text5 = list[i].Trim();
				if (text5.StartsWith("[", StringComparison.Ordinal) && text5.EndsWith("]", StringComparison.Ordinal))
				{
					text2 = text5;
					if (text2 == "[1. 基础 (Basic)]" && num < 0)
					{
						num = i;
					}
					continue;
				}
				int num3 = text5.IndexOf('=');
				if (num3 < 0 || IsComment(text5))
				{
					continue;
				}
				string text6 = text5.Substring(0, num3).Trim();
				if (text2 == "[1. 基础 (Basic)]" && text6 == "贴近是否显示距离 (Show Distance Up Close)")
				{
					flag = true;
				}
				if (text2 == "[2. 界面 (UI)]" && UiKeyRenames.TryGetValue(text6, out var value))
				{
					if (hashSet.Contains(value))
					{
						int num4 = i;
						while (num4 > 0 && IsComment(list[num4 - 1]))
						{
							num4--;
						}
						for (int j = num4; j <= i; j++)
						{
							array[j] = true;
						}
					}
					else
					{
						int num5 = list[i].IndexOf(text6, StringComparison.Ordinal);
						list[i] = list[i].Substring(0, num5) + value + list[i].Substring(num5 + text6.Length);
						hashSet.Add(value);
					}
					flag2 = true;
					continue;
				}
				bool flag3 = (text2 == "[1. 基础 (Basic)]" || text2 == "[2. 界面 (UI)]") && text6 == "原版名字处理方式 (Vanilla Name Mode)";
				int num6;
				if (text2 == "[2. 界面 (UI)]")
				{
					switch (text6)
					{
					default:
						num6 = ((text6 == "皇冠上下偏移 (Crown Vertical Offset)") ? 1 : 0);
						break;
					case "显示名称 (Show Name)":
					case "显示房主标识 (Show Host Crown)":
					case "皇冠与名字间距 (Crown-Name Gap)":
						num6 = 1;
						break;
					}
				}
				else
				{
					num6 = 0;
				}
				bool flag4 = (byte)num6 != 0;
				bool flag5 = text2 == "[3. 昏迷指向 (Downed Pointer)]" && text6 == "死亡标记持续时间 (Dead Marker Duration)";
				if (flag3 || flag4 || flag5)
				{
					int num7 = i;
					while (num7 > 0 && IsComment(list[num7 - 1]))
					{
						num7--;
					}
					for (int k = num7; k <= i; k++)
					{
						array[k] = true;
					}
					if (flag3 && (text2 == "[1. 基础 (Basic)]" || list2 == null))
					{
						string text7 = text5.Substring(num3 + 1).Trim();
						bool flag6 = string.Equals(text7, "Replace", StringComparison.OrdinalIgnoreCase) || text7 == "0";
						list2 = new List<string> { "贴近是否显示距离 (Show Distance Up Close) = " + (flag6 ? "true" : "false") + text3 };
					}
					flag2 = true;
				}
			}
			if (!flag2)
			{
				return text;
			}
			bool flag7 = list2 != null && !flag;
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			for (int l = 0; l < list.Count; l++)
			{
				if (array[l])
				{
					continue;
				}
				stringBuilder.Append(list[l]);
				if (!(l == num && flag7))
				{
					continue;
				}
				EndLine(stringBuilder, text3);
				foreach (string item3 in list2)
				{
					stringBuilder.Append(item3);
				}
				EndLine(stringBuilder, text3);
			}
			if (flag7 && num < 0)
			{
				EndLine(stringBuilder, text3);
				stringBuilder.Append(text3).Append("[1. 基础 (Basic)]").Append(text3);
				foreach (string item4 in list2)
				{
					stringBuilder.Append(item4);
				}
			}
			return stringBuilder.ToString();
		}

		private static bool IsComment(string line)
		{
			string text = line.TrimStart();
			if (!text.StartsWith("#", StringComparison.Ordinal))
			{
				return text.StartsWith(";", StringComparison.Ordinal);
			}
			return true;
		}

		private static void EndLine(StringBuilder text, string newline)
		{
			if (text.Length > 0 && text[text.Length - 1] != '\r' && text[text.Length - 1] != '\n')
			{
				text.Append(newline);
			}
		}
	}
	public static class DeathTimerSync
	{
		private struct Entry
		{
			public float Timer;

			public float Rate;

			public float ReceivedAt;
		}

		private sealed class Listener : IOnEventCallback
		{
			public void OnEvent(EventData photonEvent)
			{
				if (photonEvent.Code == 173 && photonEvent.CustomData is float[] array && array.Length >= 2)
				{
					float num = Mathf.Clamp01(array[0]);
					float unscaledTime = Time.unscaledTime;
					if (!_remote.TryGetValue(photonEvent.Sender, out var value) || !(unscaledTime - value.ReceivedAt <= 2f) || !(num < value.Timer) || !(value.Timer - num < 0.2f))
					{
						_remote[photonEvent.Sender] = new Entry
						{
							Timer = num,
							Rate = SnapRate(Mathf.Max(0f, array[1])),
							ReceivedAt = unscaledTime
						};
					}
				}
			}
		}

		private const byte EventCode = 173;

		private const float SendInterval = 0.4f;

		private const float ResyncInterval = 0.15f;

		private const float MinSampleWindow = 0.05f;

		private const float MaxExtrapolate = 0.5f;

		private const float StaleAfter = 2f;

		private const float ResetDrop = 0.2f;

		private static readonly float[] RateGears = new float[3]
		{
			1f / 60f,
			0.1f,
			0.33f
		};

		private const float GearTolerance = 0.25f;

		private static readonly Dictionary<int, Entry> _remote = new Dictionary<int, Entry>();

		private static readonly Listener _listener = new Listener();

		private static readonly float[] _payload = new float[2];

		private static bool _registered;

		private static float _nextSend;

		private static float _lastTimer;

		private static float _lastSampleTime;

		private static bool _wasDowned;

		private static int _lastBucket;

		private static bool _forceSend;

		public static void Register()
		{
			if (!_registered)
			{
				PhotonNetwork.AddCallbackTarget((object)_listener);
				_registered = true;
			}
		}

		public static void Unregister()
		{
			if (_registered)
			{
				PhotonNetwork.RemoveCallbackTarget((object)_listener);
				_registered = false;
				_remote.Clear();
			}
		}

		public static void Tick()
		{
			//IL_014d: 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_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Expected O, but got Unknown
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || (Object)(object)localCharacter.data == (Object)null || !PhotonNetwork.InRoom)
			{
				_wasDowned = false;
				return;
			}
			bool num = localCharacter.data.fullyPassedOut && !localCharacter.data.dead;
			float unscaledTime = Time.unscaledTime;
			float num2 = Mathf.Clamp01(localCharacter.data.deathTimer);
			if (!num)
			{
				_wasDowned = false;
				return;
			}
			if (!_wasDowned)
			{
				_wasDowned = true;
				_lastTimer = num2;
				_lastSampleTime = unscaledTime;
				_lastBucket = ComputeBucket(localCharacter);
				_nextSend = 0f;
				_forceSend = true;
			}
			int num3 = ComputeBucket(localCharacter);
			bool flag = num3 != _lastBucket;
			_lastBucket = num3;
			if (flag || _forceSend || !(unscaledTime < _nextSend))
			{
				float num4 = unscaledTime - _lastSampleTime;
				float num5;
				if (flag || _forceSend)
				{
					num5 = 0f;
					_nextSend = unscaledTime + 0.15f;
				}
				else
				{
					num5 = ((num4 > 0.05f) ? ((num2 - _lastTimer) / num4) : 0f);
					_nextSend = unscaledTime + 0.4f;
				}
				_lastTimer = num2;
				_lastSampleTime = unscaledTime;
				_payload[0] = num2;
				_payload[1] = SnapRate(Mathf.Max(0f, num5));
				PhotonNetwork.RaiseEvent((byte)173, (object)_payload, new RaiseEventOptions
				{
					Receivers = (ReceiverGroup)0
				}, (flag || _forceSend) ? SendOptions.SendReliable : SendOptions.SendUnreliable);
				_forceSend = false;
			}
		}

		private static int ComputeBucket(Character local)
		{
			if ((Object)(object)local.input != (Object)null && local.input.interactIsPressed)
			{
				return 2;
			}
			bool flag = local.refs != null && (Object)(object)local.refs.afflictions != (Object)null && local.refs.afflictions.willZombify;
			if ((Object)(object)local.data.carrier != (Object)null && !flag)
			{
				return 1;
			}
			return 0;
		}

		private static float SnapRate(float raw)
		{
			if (raw <= 0f)
			{
				return 0f;
			}
			for (int i = 0; i < RateGears.Length; i++)
			{
				float num = RateGears[i];
				if (raw >= num * 0.75f && raw <= num * 1.25f)
				{
					return num;
				}
			}
			if (!(raw < RateGears[0] * 0.75f))
			{
				return raw;
			}
			return 0f;
		}

		public static float GetTimer(Character character, float localValue)
		{
			if (!TryGetFresh(character, out var entry))
			{
				return localValue;
			}
			float num = Mathf.Min(Time.unscaledTime - entry.ReceivedAt, 0.5f);
			return Mathf.Clamp01(entry.Timer + entry.Rate * num);
		}

		public static float GetRate(Character character)
		{
			if (!TryGetFresh(character, out var entry))
			{
				return 0f;
			}
			return entry.Rate;
		}

		private static bool TryGetFresh(Character character, out Entry entry)
		{
			entry = default(Entry);
			if ((Object)(object)character == (Object)null)
			{
				return false;
			}
			PhotonView photonView = ((MonoBehaviourPun)character).photonView;
			if ((Object)(object)photonView == (Object)null || photonView.Owner == null)
			{
				return false;
			}
			if (!_remote.TryGetValue(photonView.Owner.ActorNumber, out entry))
			{
				return false;
			}
			return Time.unscaledTime - entry.ReceivedAt <= 2f;
		}
	}
	internal static class DownedConfiguration
	{
		private const string Category = "3. 昏迷指向 (Downed Pointer)";

		public static void Initialize(ConfigFile config)
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Expected O, but got Unknown
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Expected O, but got Unknown
			Configuration.EnableDownedLabel = config.Bind<bool>("3. 昏迷指向 (Downed Pointer)", "显示昏迷计时 (Show Downed Timer)", true, "总开关：在昏迷玩家头顶显示倒计时标签。\nMaster switch: show a countdown label above downed players.");
			Configuration.DownedDisplay = config.Bind<DownedDisplayEnum>("3. 昏迷指向 (Downed Pointer)", "昏迷显示 (Downed Display)", DownedDisplayEnum.IconWavy, "昏迷状态的显示方式：Icon开头=表情图标(BigDroop大垂嘴/Wavy波浪嘴/DownCurl下撇嘴/SmallDroop小垂嘴/Flat一字嘴)；Kaomoji开头=颜文字 Classic=(@_@') Frown=(@︵@) Flat=(@\uff3f@) Squiggle=(@\ufe4f@) Arch=(@︿@)；Text=纯文字「昏迷」。\nHow the downed state is rendered: Icon* = face icons (BigDroop / Wavy / DownCurl / SmallDroop / Flat mouth); Kaomoji* = emoticons Classic=(@_@') Frown=(@︵@) Flat=(@\uff3f@) Squiggle=(@\ufe4f@) Arch=(@︿@); Text = plain word \"Downed\".");
			Configuration.DeadDisplay = config.Bind<DeadDisplayEnum>("3. 昏迷指向 (Downed Pointer)", "死亡显示 (Dead Display)", DeadDisplayEnum.IconWavy, "死亡状态的显示方式：Icon开头=表情图标(BigDroop大垂嘴/Wavy波浪嘴/Flat一字嘴)；Kaomoji开头=颜文字 Classic=(×_×) Frown=(×︵×) Squiggle=(×\ufe4f×) Arch=(×︿×)；Text=纯文字「死亡」。\nHow the dead state is rendered: Icon* = face icons (BigDroop / Wavy / Flat mouth); Kaomoji* = emoticons Classic=(×_×) Frown=(×︵×) Squiggle=(×\ufe4f×) Arch=(×︿×); Text = plain word \"Dead\".");
			Configuration.DownedTextPlayerColor = config.Bind<bool>("3. 昏迷指向 (Downed Pointer)", "颜文字玩家肤色着色 (Tint Kaomoji/Text)", false, "开启后，颜文字或纯文字模式的状态文字使用玩家肤色着色；关闭则使用默认暖白色。\nWhen enabled, kaomoji/plain-text status text is tinted with the player's color; otherwise the default warm white is used.");
			Configuration.DownedTextOutlinePlayerColor = config.Bind<bool>("3. 昏迷指向 (Downed Pointer)", "昏迷文字描边玩家肤色着色 (Tint Text Outline)", false, "开启后，昏迷文字（头顶标签与边缘指示器文字）的描边使用玩家肤色着色，字体本体保持暖白；与图标的彩色描边效果一致，图标模式的倒计时文字同样生效。描边会自动压暗以保证可读性。\nWhen enabled, the outline of the downed text (overhead label and edge indicator text) is tinted with the player's color while the glyphs stay warm white — matching the icon's colored ring, and it also applies to the countdown text in icon mode. The outline is auto-darkened to stay legible.");
			Configuration.EnableDownedEdgeIndicator = config.Bind<bool>("3. 昏迷指向 (Downed Pointer)", "显示屏幕边缘昏迷指示器 (Show Edge Indicator)", true, "屏幕外的昏迷/死亡玩家在屏幕边缘显示指示器。\nShow an indicator at the screen edge for off-screen downed/dead players.");
			Configuration.DownedEdgeText = config.Bind<EdgeTextModeEnum>("3. 昏迷指向 (Downed Pointer)", "指示器文字内容 (Edge Indicator Text)", EdgeTextModeEnum.NamePercent, "边缘指示器旁的文字：None=不显示 Name=名称 Percent=昏迷百分比 NamePercent=名称+百分比(默认)；名称最长12个字符(忽略富文本)。\nText next to the edge indicator: None / Name / Percent / Name+Percent (default); names are capped at 12 characters (rich text ignored).");
			Configuration.DownedFontSize = config.Bind<float>("3. 昏迷指向 (Downed Pointer)", "昏迷标签字号 (Downed Label Font Size)", 18f, new ConfigDescription("昏迷倒计时文字的字体大小；与玩家名称的间距会随字号自动调整避免重叠。\nFont size of the downed countdown text; spacing above the player label auto-adjusts to avoid overlap.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(9f, 60f), Array.Empty<object>()));
			Configuration.DownedIconSize = config.Bind<float>("3. 昏迷指向 (Downed Pointer)", "标签图标大小 (Label Icon Size)", 20f, new ConfigDescription("头顶昏迷标签中表情图标的像素大小。\nPixel size of the face icon in the overhead downed label.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(12f, 96f), Array.Empty<object>()));
			Configuration.DownedRingWidth = config.Bind<float>("3. 昏迷指向 (Downed Pointer)", "描边粗细 (Ring Width %)", 8f, new ConfigDescription("图标外围着色描边的粗细，占图标尺寸的百分比。\nThickness of the colored outline ring around the icon, as a percentage of icon size.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 25f), Array.Empty<object>()));
			Configuration.DownedEdgeIconSize = config.Bind<float>("3. 昏迷指向 (Downed Pointer)", "指示器图标大小 (Edge Icon Size)", 30f, new ConfigDescription("屏幕边缘指示器中表情图标的像素大小。\nPixel size of the face icon in the screen-edge indicator.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(12f, 96f), Array.Empty<object>()));
			Configuration.DownedNearNameGap = config.Bind<float>("3. 昏迷指向 (Downed Pointer)", "近距离标签间距 (Near Label Gap)", 28f, new ConfigDescription("近处玩家名称正在显示时，昏迷倒计时/状态图标与玩家名字之间的额外上下间距（屏幕像素）。\n调大让昏迷标签离名字更远。它不控制名称与距离两行的间距，也不改变近距离触发范围。\nExtra vertical screen-pixel spacing between the downed timer/status and a visible nearby player name.\nLarger moves the downed label farther above the name; it does not change name-distance line spacing or visibility range.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 120f), Array.Empty<object>()));
		}
	}
	internal static class DownedIcons
	{
		public static readonly string[] Downed = new string[5] { "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", "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", "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", "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAB7ySURBVHhe7Z0JuFxFlcdxRXAbdUBFR0VBUFBBEVH5vvl0XD4UVHQQlEH8lBEYB8R9AZkBFWUQUVFEgXEXERCVRZFFcHQQAwjCGDYNSYxJSEJe3nv9+vbden6n6tStur297tf9tuT+k3rdfe+pU6fOObXeqrpbVahQoUKFChUqVKhQoUKFCpspms3mYwm75Hn+qjRP3xan8dFJlpyU5RnBfnLvpCzLTuL+UUmevInfzyfONsqiwkIHxtq6kTd2w3BvxoifxKjnpVn6S8JtfL+fAMlgIO5K4l1BOA2+ryU8TpOrsBAQ5/GL0jz/EAa6NMvS+9RuPZDzP+e/hiwrf9ff/FH6Mqgh1hGuwME+EEXRc1SMCnMFbLB10kz+CSN9GkPcbM3SAmNQMWRg3OJa+L2VpoU+dA7utYL0E8KVOMMx9bz+LBWxwmyAqn1PSvkXKOV/Vv0X6GzIfoOLk2NQ/73V+OXv9ncIHCEiXI6cb7+jecfDVOwKw6Ke1F9DO3xJa/ttDdTZMHIPCks4BDzfkL+G0FkIIZD3dmqFd/L1kZqNCoOCXvgBKPJaq1KLrsZoMYCDOA08NqZpupzP2+j1/47Py5Ks8TvCDYwELpfA9d9y/U5ql+V8HycF5dAOb/R2GYwcgSykfx99lGMvaF7wYM1WhemAwvbCGFepDg1CBZvvUsIDRTsQbyVGvBSDn5jk+eu4tMt4c/wJxHu4su8KaLcSusnJySfyuSty7NtIG4fjEF+kar8K3itMIiGcPKF8pmYoy4cj3EqNcJgmVaETJpuTT6TUfxFlJao3VWzZ+CGgHSP8FOUey/09VjVXzdqYHf6PILw4TtMP4RAX4mirVAyDNlm1ieKPUoi86TU41t7KsoIDvfo3YshCoYUSTbBKDUFp/AOl8whK65OUxZxjfb7+0Y1mejjOcBnOEKtohbxt8mse5DuOfjqfj1JWWy7W5esehTLONZoBJaUFnTwHlP3rKInewlflsDAQ5dGuSZ59GUeYsJK25EU+XY2gwOHvSfLo9cpiy0OtWXshJfl21YcqSpVlFOYND93dDK/eplEXLOrN+tPpM5yCo25Q0dXwzhF8/hzohJ54QvOEBymLLQPSM6YE1EUBXin+04ESNUX7fuLa5tpFNZyq1Wo7kL/PIP+4zYnmr3CGcj7J47UT+cT2Gn3zxbXNax9CCfmm5tsqRQ3PH6MgBxQokyrP1aiLEjQNO1N7XaNZanMA4wRaGeAES7m++c4mksetUcZlNruh8b1SBBh+Ms3jIzXaZoGYUQp5nzQZBOV82+8C8r62ltf20mibD8jUU1DATSaXkmntEIWGF0BzM6X+eRpts0LUjHYhf5drVou8h44goCZY02gs7pqvBNq27ci46eyZjLpq0E2YKGgazl2xYsUjNNpmCzp9x2uWC8OHehFQEyyXQqNRFi/I0LZpnt1aZFYyGcyhO6CUj2uULQIMZffHyGsk71YvXidOL4wk7uT7vM1zjASU/J8WmTSeLg7gPV3QSBtb5BTpWL3+TKp7LRxaMFztqPpJs+R3fCzO5whU6WdLJkrGl+9k0lznH8Z/u5JvkRjPx//eO4E1fKEvnQdJ8uRMJV88iNLoI0Z68uCrN+sADhj/UCXforF6YvV2FJYbRSdFIZEgBUXVRRN5rJIvfMhTNCt2aHwbHBgff1jJKwCZEqdPYB59h/oShxBwL0OvL1byhQt5lEq7/7dyRmz179yZ2uFjSl4hAKrZhprgDtFRyQm0yaSpkJHUwl5pFGfxL0XYUgaCqr+RNT6rpBU6wHQMdd1BqLtAf19V0oWHelo/ykipAodBgHNcoaQVekDWPuIEkVWlOoB2CAX1vP4aJV04qDfrO1JFmUehnYyfpMlfNjY3PlbJK0wDOn3/ahRndOhqAW0KsnQlv7dV0oUBjG8eeJQ7fdqBybKkFm+G89uzjDhLLzQ6LZyg1JSermTzjymGc4WgxgHK7Radvi1qlm9U0Cn0dVa36NRMEhW1QNJoNl6gpPOHB5oPPAZhVhdCquGLnmuW/lpJ+wbxdyYcytDnC0menZ9l6VU2ZFfx+4dcPyVP04PkUStJbK3R5h0iC3I/WR760IAT+Myjnbj+BIJSDQbiH0hcUW6gX6vbJI1vVbL5A6X7BCtfKKAt+Vme1snAs5W0JyDfkXHuCTjMjRi4WBTaC1IKcIoV0F842ZjcU1nNKcjfrjR/RyPLpchyH7JMZk3+iS745HqK827kcylXL4D2CETfUaP3BYaGv5L8hg7gdEyH8V+UbO4xmU8+KW2mG61w7Q7QzwMeWVjJ6OAHKKxmIikcH8tTg1aBLp0QKDlJ8uQkvs7JTl4M/zocXGomWxwHAI7SwBEum4qn9lV2PTHRmNgdBzKLTgud6KgAPn/l2vx0CDHcOV4obzABXiuTFtOucxvLxx4HbSpxWvn4zzCE9/x9BxzpT9Qks9bhlKXrKP1iTc7Ay6LBdYTl0zit+22/h4DXj2t57cnKviuSZvJZoS94aRDQITxNyeYOG+sbn44nW68sSiYCqVCyeVNJp4XUAIaPyZTyEp4B3+Ja+LsUvEJwgjGcYB9lPzLU4vjFlMSVJhHgZSTtovPrZSl/b7/mgLwrcYSDNJmOkJqStO3jY5cmvDR+Kv0NJZ0byDDECFNkzGcKg16iZH0Bxb4QZ+qr3Xcw6YUjDuccWjWqE7xUkxga9aT+KtrwoLkLQmEQCfa7e4gjaL3nPwkqr4AmTJ6eaortqKfxkULn+dkgkFpJyWYfstUKb7TKaPVG2rd6vf5MJe0bjTwxDgXfDYSb4iT+IR2cMyVESfQd+hM/JlxCc3FLmibFJgxBSaElWdLJUcya0d4/B5mmbFrwd87m0uP3ILBxCcaBy/Fx3MtlZKVJlyBLx7VpVR4S38elIzw3w0JK1ickwUIZ6gQCSv95SjYQZEtXHMd7b8o3PV4vdUUURTsx+jgmTdP/NYkCK4sqVJUrwHBjU/nUUzXqwIDfw1G6X7QRKD5UPnclrd82suSURjp1MDXGK9HT3gS3v/BLOGTpLINWR+KPuU5plqeCD1URShCHNkRFPm18Abqf/VpAl3Xfa2XwGRCY0p8PXvqHAaOQf0bx5gkaghQKKZQKxDB8PESjDATZwiU8LD/Hm0/ScYDmvLgZv1Cj9MRko7En+jsDmR7Q6AFv4WtlhuZrGqUNxP11EU+d3kGeIyjZ7AADv9akVFJIIfS5SjankIWkGOH7RgiVxyrHyieg+ThOyfsGNcfTUHYwQlEjKU/uLWUo93IlHwhTUxueSnwz1SsIHZc/5hp56rhtjOuvMARCWtR6RZzvKtnsgGrmxyZtTdQlTNvVoK3cScnmBUmenellKzsnyl7TT/MSIskaLfxsUH5/mphYvZ2SzhjyBBWuhmeRhm++7pQaV0lLSLL09zZO2Q7EmZQ+mpKNFloidEJChLWK0YR/omQzAry2hc0LkiTZn7b9KBPy9O1cf5msllGyaYGDtq+qcQrN076XVcn8BHky27pa84qzT4yyqaPaPhjehnmpJgD0H96lZCU00vSthsDkT5zGxhNQ2x2tZKMFjI+1aWqikqAmKsMkJRsIdJL2QqFn0X/4q2HUAdyXY9rO7KeGEcNAqz12kdErJkmTvp9L1PPkVSYSMPnVIEAP085wiqzQvwW3+yifH5R5EaJ2naWM0vj9wrs1LZrVWzttHOWW7LLSZzBCb/Mq4Hpfk3ADA2FukAR8glZIEryHj4GWLuP1u2GoSw2DEJp5F0JAP4Hy368suoJ2sG01solP7SW7d5WsJ6I4+qjnYfkIyOvadeu610ibomhnapoLkbVhIgSAz72U6EOUtA1l/Ra6zWSthZKUQD5PC+m1EjFAv3so2WiAR+9MKdUOkTW+ExLBP6VkfQElHIyCgn1ymoGCrzWav04IM5c1TlZWHVGLa3sTw9CGfAX9rkSmP2HOLPAy2PTJ6zeUpA0y8YTB/LbwIm7Zkbt1SKUWNQSQt8j8DiUpoZHnexgC0JrWoDaZFlLyfELWQOY3/xqN/p9LUzrkaZiBbUZaDG0y4BXmr3uFCFD2UcqyDdx+MApYJnQhfwHX/0vJegIH1Q0t5fik+x4lKUFWO5G34rF4CBff8RB02gDKZakF/iT3Q3qufUdJSuCW0P+f0LSmwfUblGw0wAHMoU02EWs4TegPSjIt8PBXm0jA9SFaBe8GT2fTxUBTvSZ46AyaXcgujuNPvB8qSU9Qki8K4/PHxKcm3F9JSsAxjnH0DvQ5xvSriR/KAf+fa9QSqNY/bclzZHW0yS16uw3ov2VK3uoH/vVhJsBKEO8mIZMZn5AVjut9rfLVEmLOAHKKaOWFce6XDEVJdICsdmGMvY/UPGTmThvP0RfO17Wak9WzPo53WHhdqyQ90d6PsDJSHb9TSUpoZPHPDAF0MiE2NTX5Dtn1gxFeyoimtPNHQF6bUdS+VqKWRG80BAEtDrCq2+FX9STxhcrECWTNG0co2XCIm/HLDUfglWkT6bf3jyE/LPROCa3C4hxXdtsNy+1Hcv96oXNxBTjAr5SkDWT+UyF9kU6W/lZJesI3eTa/QZqnKkkJURYXh15Ac7NeNpDFKhjcPOwKZcGZ3q0kBahJXuTuu0+6XhtkWKokJazOV2+Lg/jRgEwMaX+Jfsy3lWw4oIwPlhIwDmCUuUEeUypZV8ixqRhwqeVhlWlDweea6c7IkV5tqEQB1by0fx3jUYK/LDRhUyOQtJSkJ2SxhokAnBMIyMftSlIChnuJIVCEiz34Sd8nM4dYu/wLojQ6XkkKyDCWpsMk5tKkRlk/1hz7OyVpA3m6wNJbnbp4OOJtSjIcYjohNgGYq0IFaRb3VZ1SpcuBjcLAxA2VgPBjnRZERHmyn5wGpj+3WpGveESSxrYZUg/H8//Ah1KUgdOqUmxaLj0c43wl6QlxbAxh5usLeT2Pjk8YRV6c9Dry9POJRmN3vey2fa0v8QKdFsvSx3g28UsOwO8NY2OdawABeX2fpSefOjVs4yW1kRyjh9fLFmWbgMlA4WF99agR8EQfX3moERtJ48tKVgBFvlnuxUljUi/JtTcSVxI3PMz9NO46+4hsutmynB7X+149g+N/2/Pw6aIP2bff90EWVPUHmYgtfLo0AXubm6BIr0cTIJDaEVp1GptfB+GnZDMDPLahJOhBBtZ7iwzkncenrUDpvgZxAiqPTiuHqNqvsPTSE85+QofuVKrBYjGGi1tv1A/XKCU8MDX1D2nmTiArK50O2cFKNi2kPTaRQBufLL1y48bpN7pIR488eP2pIwqo+do2e+Lob9DbRVrob323NQKCFThjqR+gehZgo+EWjY5H0S5+Asgyd0BBfa29IwPfE3ovnOWBEpNOs1yuB9+KsPnBKZdKs6BRSqBmMLtqWpUhn1LFKllfQPbvtvJy/LI8vYe0juZ320Mhs2gmT48kjx2naxN75H3bRs9Glpws9x29ABmWnjDN1C5p/U8Yz8lI3JOUZGZgmKELEBxzl3kzk/dEJesJhDCPaluFw7EyPPT5SlZA1huiuGIM7RThQGZXMcTq+qYO0itNqbr4aZosvzu/e9pDo0MQfwf4mRXLIb+wJCPrRmiup+b6PuF8+U6JNG2+wDmuBP6YazjOMZpECcS9zsZRegD/aR+0QVOat3B5pr/y30oyMyDov1vGlqljTIKyKKSvRRYMR86QOE4Jlo9mLk+7THM29iCNqx2dAH8Z49qPHph64GlK1gYybKvQIi2bngDjzGi1Ui2p2bE58MZUXQTytcKn74MAI/+502FYNAk7kD+/9Ezpp5v6FqDjlnkP1W+W/kJJZgaE/bxhLBkPqmBahb5nAGl3DzeRAuEcHxzsZ0rWEfSmd0uS5PU0N/tOd5Km9LbJcDAFbAN/TFqkOeNFotKRI88l45hg9BL8NsHlUT9LesvG5VmFsi0BQxezgJbexqGf9I9K0hU4vuyJ0LRsEKCP4YaClBrtCfvMGMZ5/3PN5kFSHj5IUoXwX64P3VNVUJuY2TinwCIdgCKuU7IZQ+RkPG8cTBCm4RXvvrt7Vl8C8lqT6XBlV4LsA+T+JqGzcQu571qyZEnH9YEhGFIe5+OSrrNTlq7p9fRyWsDgEsM4yJRhnKeXK0lfoE3UTkqgHEqOgIzfsqQ5fSZ7AR5nWf5O8V6JAqlBlHQoTExMbE+t+C304i1bwKfXCuh/M9mY7PqIlhL8LaEL5RdQQ56gJD1R3jji41Nr9ZxEmhZZMwv2pdkgQAkDTTNShR5i+YQG8oKmWSzby7sOdbphqsmQL9fjZ4VnUR173tRiP1LykYE+yvPQweko+AY6l8Wj7QKkjdH/RrgI475Zo3WErHC2UVp1kvZ84BUCB2/bo2l4pOlUPsyBk5Qss/TaMrbMDeMs7dl2t4Io0p8wy6I9L0LQ2yWtO2jv36BRegLyrTH8u5HDjLFhEtRSnqfcp9QOvXavF6TzNhXH+yD7q+XZiLTZpL9rP1UvceTdBwa+GbE6lvkPJZsWMqowPAI9CKh506GWr6FAWVJtGYeKzdOrlaRvyNJpExkYw3cwmIBStSRN4+O4tqdMgXLpQfLQQ9YkUpr2y/LkVOQyS9MFXnHKS5sW7sjDqldo8gsOlNqP4PTG2oXsanyurx1kESuFy3cCVR8C9JSM1Yd4n6GvAVTJVl5xgJuUZCDgqaazIvDVtQ+tkPE0Pee7yciqJEvN7F4BVZjNMN/104FmZ0EeQonhX0Jn0jzdFFjd2rw40HE+QMn7Anb6nMRzfJwe0Fs21L5BlO/7AKbUKuM8lZUrPWenuoGqzXiroBC45AxlQ5ZQ0JRp7Wfh9ZE8O9DkZhUk92DSn3ZyqVarPQWdHYps5hQ1h5LsfBegny9otL6RZFnLTu1CF8MtDEFoHQU4xoVnre3nUXA30Ik6DK+1JVoF5neRhlVK+Nn63f221xyQ63ZK2Mg2hU4H2RhCIdmI9Euo3S7GeF+kmTrNhCz+Jvr7OTL9kc5YqaPoZS/LT4d1Rhs7SCOYCbRBMPQogA6NWejgGVvPos0hQ5N9TQV3Q40+QdpMTQ3jEKbTOYT3veJwnnFk+tyqVTfN6aveSXqbRtIwQ7Bp0SK7y5MDTvN5ZTswdBRV4m94ZomsQ5j54ZJRGn9MGBmmWgsIUHjC95G83oT27i148NWhMvoF8eS9gWfV6/VnKLt5AXk4EDnsRI7rkxidBd/VMEaH3ndFlyvpr8z4hViwkKb6j8LLpmeDAN6/V7KZAcH8DhSTIS95p0e5w4BmYTeq0fdh1IsJS8nU/XwmZEJO3cHYiZy3s55rt3Pv2zLFvL62fgeNPu+Q5xeUOLN+sR+Qj7/QRHx80C1rrcChtvWP7L2zaRpD7dgqD90MY/VgQFv7XiUbPfBqkngMJftZ43m063g+viulbKexZnPm7dkcQB4D0yE7Fwe9HeWvTNNkA047gbOu4fsynPk33DuL6v4N3R5nDwr09HT4mo0ozj6uoCYDzCV0BDweg3fpYgx1AKoZAd4+L7uBFwtkocamTZseL4dpobdHobJZOehZamJjEGlZnAMQBNTgHRfNDAQMbZ9RtzCnSv6jklSYR9BPM+9mMLbRPoADtfTwB2bhAMEqFe8AVDtJFEU7K1mFeQJNjdlj2WofCmhfq7anRT1xh0J0SCRPq7d+zCPkjao4wP3GPM422kTHfa7anhb6Eohgy7VPhFqg62bJCrMPefhkDEHpLByAIKD6b9t3MGPQDPhnAmY+oBhm3E+C1WvQ5wmMJr5u7WJt4owvGEn77xClwX555wCaWJREr1OyCnOIZcuWbU07r6/nsZ0/5wAU2HtlR5aSDo9aXAvmA8QJpCawtUAyw8WWFYYDpb9lx5UNAnkWoWSjwZJm86F0+O6y6ZUTy7Ks59alCrMDOnn+DAMz/MMe1iSjrf4daAY+Kcyt8W2CzglixqJKVmEOUM/rz6L/FRzYZYOA60uUbLSQlSUyGe8TtY6gicqbrhb2K802I1DFf0X07u0QFMY8/jclGz3iLL3SJuwS9Z1Bmoi3KlmFWYTsj6DA6RF2gR3EBlk6OatrIEsdD9PulKoeeSQ5o1VCFfoHNjhF9O0M75xAQL/g60o2O9CzgmVjYzlxFaDR547hCjODbCChoOm6A+8AgizPorH62Oyf1RzlwYEERShqgbtHOv6sUEIja9iTT0Tn4gDBpBwd8ZHvf+gI0noYtcBfJFErCF5oBNFqCAdR0gojBLXrcylgfqt+oHOcIJvTdzPW03qwB19CqSraUKtN/x6cCoMB4/uj+lqqf9r+vo6/GxlI86EIZA9+0kkI5wgC7l2kpBVGgCiJ3mQUW+jZBgG6jofa/DFTFI+JiydR0hSIM9irjS5n6lUYDBN5Lh2/4KQR1bUqmtI/f09kSfxyL5gI5QWjKZjqdtBxhf6Bjn9S6Lio+m1NK+sN57W5lQWbeGfwqnPrAE5A7l2vpPMO5Ho0Y+gDsyw7Bef8HrJdmWbxVSj4Kn7/lPufIRw41EaKEUOWixtFGp22FzKZnlfS+QNC+FNAnYe6hxOAEcPcv9gwgF2unZ2bZpk5qnY6yAreLE++JvGUxbxAzk/EWXW1jzN8Sa/3dTtCdk6BLHI6t55ybQW0zkAtoMKizLYz8WYbesbxlyjdZuhkYGTzirRyumvIqvIKuJYy7j55WXPZnL+gWg7MQPaWw66snFyRy7LzueNpI/OCqeaUP0+486ggmpVHlF0gr5Zzj68FvkbyBu4IQyMfng4HunVTtGmg4+WGRSNPgkOfrB4LJwU4x9lKunBAafnPstA+CFDkGjnRQ8lnDSRF6Um19HilOeCMawjXoMRvUMWeSr/g6/y+mg6VeVe/QxgP2rt6ndY5SlBb2nbfjK6QX2ooU0sVxl8hi0GVfGGBUvcbI7oqvlS9Au7fPDY2u50sxsz7mcSApO2AA14nnUC+djyKRjZxREnyJpzBLLQQhPHp64xukWUXYPw90ZE95VSNboOXg6p/6Lehzhrqef4MFFi8OcN6rzqDd4Kl9Vl8aFFP6+80CSmQZz1pHqa3+wL0BxHPdMAcKHlt5xqPEuPNaBfS1DV+3vCh7pBh2jMD5x21PN6b0qZ71VwG2p1ATgTVKCOFvKghSZMbSTOSUj/TM3LkSBri/wI+MZ93jUfju+qtkcO8lj5L9fUvXXS2mGZXi13FwGXCZsgGQZanq8Jz9UeJCy64QE7u6Hqi6CCQyazZHAmMxbUXUSD0gMtAT0G7j/HvHeT9iQsCstXbSA9MM9ChOaBk1Wn3+j7Be3MDtdMr6bD61T1Fu+8LCsavyyt0NMriAk7wHpML4AzfmkEBbdvX+Bjo3YOLHdSSh2DclllUV0CsbvieyYMgjbI4gROYA6cFPoPqBNQIDtJeyxkAGm2zRZ6v3pa8fkmz7WvHQC/mOl/kHEGNtriBE5iDDAXWCazxi+9kXIBixtLZPHhinhHn8T70feTVrgZh/l1w2OyeppKhI7IOy8qLzFMKHKgaL6Y2mNPZt9kGheCDOLiu5W/JuwYBNFGaNwYati4aJHlyABmc8EpoCeUmYYIgZwoOfIbwQgKlfl9KvZkgE5QN778LGA2sqy/g001HAnnKluZZcZhSuRYoK0SAEyyj9By1IJ58DQAZPiL7eZoNyWgpf+EwT4Dxb6TW2zIO3JC9hPT8zRHpAqsUUY4LqqRAQSjzLpT0gU6vmVtIwMF3p6Y7nebO1HQCn58wb8EoKE/O5tpAr7PZLCDbmDBs6f1AXkGBovh0oH/wAMo9O46nXq5s5h1Naqc0zw8lL6XzDp385jPo6TuQl3H6RsMf5LSYMVYf25ESYF4sZRAqzXwSOihPYBWeHzkfZxXJ+X7IvT/O+BXkMJtlHJyshfxO9kB+msErZnN6edEhSqIDKRF3q35UaV55bcoMwOBC5uuvz5rZf3Bvr2HfQNIJcmQ9NdZLaIaOxegXkV7pYRESF7LZUJbdgTwuo9RXZyt1wqpVq7ahw3ccSrIvggBlZYZK9aEVOMQ9WZacj7E+wv398jzaicvbEDSl7hAa2YJFPHkj5yEY+9OEnxFWCu8ynExhCK952XCYiUbW+NzyseUL+rDLBYGJiTXb4wjHo7SS0r2CW4KZTSsrPAQOlRL+imMs5VMWg3wXg54jIc6Tc6jKz+Ha9+Xwau4vTcN3/7fApxmkb4KXLQRpTMD7q9UK6RlgY7P5WBzhQxhluerToKz43mEYdOJnHc2F8r0QIjMOfBKGn5XH3lsU0OcjG2l6EKXpMlRtNaywyg+N0fK9MJi71hLc2FxKdEhbMjShk+G5FoIrUtVfQxt/2FpkVvErjBIyzqZW+ESaZbeo3kvwVXOLsVpDWIUXxnfXykYOf3cCjrmE/saJyPY8FbPCXIBeuSym+DgGuIbQtd0WFAZ1oWTYspHlO380ZjtI637C1aR9fBzP3RtKKvQAhtueztx+GOZkDCi99jtph81hCsNAeBBuo2r/Hl3J98Z5/rKFtHuoQhdguwfhFNtRLT+/ntRfSbv8LkrsJ+iRn5Fk8TkY9aI4iy9zges/wMhnCA3hXUmSMHzMd5/AsZRlhQoVKlSoUKFChQoVKixqbLXV/wMVk0CLt2YK+QAAAABJRU5ErkJggg==", "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" };

		public static readonly string[] Dead = new string[3] { "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