using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Management;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using GCValheimStats.Batch;
using GCValheimStats.Collect;
using GCValheimStats.Networking;
using GCValheimStats.Security;
using GCValheimStats.UI;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Steamworks;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("GCValheimStats")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.1.1")]
[assembly: AssemblyInformationalVersion("2.1.1+63a748d2ad7345c0a2740a861e60cd06b8d90bb1")]
[assembly: AssemblyProduct("GCValheimStats")]
[assembly: AssemblyTitle("GCValheimStats")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.1.1.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace GCValheimStats
{
	[BepInPlugin("com.gchallenger.valheimstats", "GCValheimStats", "2.1.1")]
	public class GCValheimStatsPlugin : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<string> <>9__17_1;

			public static Func<long> <>9__17_2;

			public static ConsoleEventFailable <>9__17_3;

			internal string <Awake>b__17_1()
			{
				return SessionManager.SessionId;
			}

			internal long <Awake>b__17_2()
			{
				return SessionManager.SessionStart;
			}

			internal object <Awake>b__17_3(ConsoleEventArgs args)
			{
				KillFeed.Instance.ShowAllIcons();
				return true;
			}
		}

		public static GCValheimStatsPlugin Instance;

		public static ModConfig Config;

		public static StatsTracker StatsTracker;

		public static EventQueue EventQueue;

		public static BatchBuilder BatchBuilder;

		public static BatchSender BatchSender;

		public static BatchTriggers BatchTriggers;

		public static SessionManager SessionManager;

		public static StatsHttpClient HttpClient;

		public static QueueStorage QueueStorage;

		public static MainMenuOverlay MainMenuOverlay;

		private byte[] _aesKey;

		private byte[] _hmacKey;

		private Harmony _harmony;

		private long _steamId;

		private int _updateCount;

		private bool _playerDetected;

		public long SteamId => _steamId;

		private void Awake()
		{
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: 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_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: 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_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Expected O, but got Unknown
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Expected O, but got Unknown
			Instance = this;
			Config = new ModConfig(((BaseUnityPlugin)this).Config);
			StatsTracker = new StatsTracker();
			string persistentDataPath = Application.persistentDataPath;
			SessionManager = new SessionManager(persistentDataPath);
			SessionManager.StartSession();
			QueueStorage = new QueueStorage(persistentDataPath);
			EventQueue = new EventQueue();
			HttpClient = new StatsHttpClient();
			_steamId = 0L;
			(byte[], byte[]) tuple = GracefulDegradation.SafeDeriveKey(_steamId);
			_aesKey = tuple.Item1;
			_hmacKey = tuple.Item2;
			BatchBuilder = new BatchBuilder(EventQueue, () => _steamId.ToString(), GetWorldSeed, GetWorldName, GetWorldPreset, GetGameMode, GetWorldModifiers, GetIsServer, GetIsDedicated, GetPlayerCount, GetCharacterName, GetCharacterUid, () => SessionManager.SessionId, () => SessionManager.SessionStart);
			BatchSender = new BatchSender(QueueStorage, HttpClient, Config.ApiEndpoint.Value);
			BatchTriggers = new BatchTriggers(EventQueue, BatchBuilder, QueueStorage, BatchSender, SessionManager, HttpClient, Config.ApiEndpoint.Value, _aesKey, _hmacKey);
			GameObject val = new GameObject("StatsOverlay");
			val.AddComponent<StatsOverlay>();
			val.transform.SetParent(((Component)this).transform);
			GameObject val2 = new GameObject("TimerOverlay");
			val2.AddComponent<TimerOverlay>();
			val2.transform.SetParent(((Component)this).transform);
			GameObject val3 = new GameObject("MainMenuOverlay");
			MainMenuOverlay = val3.AddComponent<MainMenuOverlay>();
			MainMenuOverlay.Initialize(QueueStorage, HttpClient, _aesKey, _hmacKey, Config.ApiEndpoint.Value, _steamId.ToString());
			val3.transform.SetParent(((Component)this).transform);
			try
			{
				_harmony = new Harmony("com.gchallenger.valheimstats");
				_harmony.PatchAll(typeof(GCValheimStatsPlugin).Assembly);
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[GCValheimStats] Harmony patches applied");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("[GCValheimStats] Harmony patch failed: " + ex.Message));
			}
			object obj = <>c.<>9__17_3;
			if (obj == null)
			{
				ConsoleEventFailable val4 = delegate
				{
					KillFeed.Instance.ShowAllIcons();
					return true;
				};
				<>c.<>9__17_3 = val4;
				obj = (object)val4;
			}
			new ConsoleCommand("gc_show_icons", "Show all mob kill icons", (ConsoleEventFailable)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[GCValheimStats] Plugin v2.0 loaded");
		}

		private void Update()
		{
			try
			{
				_updateCount++;
				if (_updateCount % 300 == 1)
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)$"[GCValheimStats] Update #{_updateCount}, player={(Object)(object)Player.m_localPlayer != (Object)null}, detected={_playerDetected}");
				}
				if (_steamId == 0L)
				{
					long safeSteamId = GetSafeSteamId();
					if (safeSteamId != 0L)
					{
						_steamId = safeSteamId;
						(_aesKey, _hmacKey) = GracefulDegradation.SafeDeriveKey(_steamId);
						((BaseUnityPlugin)this).Logger.LogInfo((object)$"[GCValheimStats] Steam ID obtained: {_steamId}");
					}
				}
				if ((Object)(object)Player.m_localPlayer != (Object)null && !_playerDetected)
				{
					_playerDetected = true;
					if (_steamId == 0L)
					{
						_steamId = Player.m_localPlayer.GetPlayerID();
						(_aesKey, _hmacKey) = GracefulDegradation.SafeDeriveKey(_steamId);
					}
					StatsTracker.StartTracking(Player.m_localPlayer);
					ActivityLogger.Initialize(Player.m_localPlayer.GetPlayerName(), Player.m_localPlayer.GetPlayerID());
					KillFeed.Instance.ShowAllIcons();
					StartInventoryCoroutine();
					((BaseUnityPlugin)this).Logger.LogInfo((object)$"[GCValheimStats] Player detected, steamId={_steamId}");
				}
				else if ((Object)(object)Player.m_localPlayer == (Object)null && _playerDetected)
				{
					_playerDetected = false;
					KillFeed.Instance.Hide();
					TimerOverlay.Instance.StopTimer();
					((BaseUnityPlugin)this).Logger.LogInfo((object)"[GCValheimStats] Player exited world, kill feed hidden");
				}
				BatchTriggers?.Update();
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"[GCValheimStats] Update error: {arg}");
			}
		}

		private void OnDestroy()
		{
			SendFinalStats();
		}

		private void OnApplicationQuit()
		{
			BatchTriggers?.OnApplicationQuit();
			SessionManager?.EndSession();
			SendFinalStats();
		}

		private void OnApplicationPause(bool pauseStatus)
		{
			if (pauseStatus)
			{
				BatchTriggers?.OnConsoleSend();
			}
		}

		private IEnumerator InventorySnapshotCoroutine()
		{
			while (true)
			{
				yield return (object)new WaitForSeconds(600f);
				if ((Object)(object)Player.m_localPlayer != (Object)null && !((Character)Player.m_localPlayer).IsDead())
				{
					BatchTriggers?.SendInventorySnapshot();
					BatchTriggers?.Update();
				}
			}
		}

		private void StartInventoryCoroutine()
		{
			((MonoBehaviour)this).StartCoroutine(InventorySnapshotCoroutine());
		}

		public static void SendFinalStats()
		{
			try
			{
				if (!((Object)(object)Player.m_localPlayer == (Object)null))
				{
					StatsTracker.SaveStats();
				}
			}
			catch (Exception ex)
			{
				Log.E("SendFinalStats failed: " + ex.Message);
			}
		}

		private static string GetWorldName()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return "UnknownWorld";
			}
			string worldName = ZNet.instance.GetWorldName();
			if (!string.IsNullOrEmpty(worldName))
			{
				return worldName;
			}
			return "UnknownWorld";
		}

		private static string GetWorldPreset()
		{
			return WorldStatsCollector.GetWorldPreset();
		}

		private static string GetGameMode()
		{
			return WorldStatsCollector.GetGameMode();
		}

		private static List<string> GetWorldModifiers()
		{
			return WorldStatsCollector.GetWorldModifiers();
		}

		private static bool GetIsServer()
		{
			return WorldStatsCollector.IsServer();
		}

		private static bool GetIsDedicated()
		{
			return WorldStatsCollector.IsDedicated();
		}

		private static int GetPlayerCount()
		{
			return WorldStatsCollector.GetPlayerCount();
		}

		private static string GetWorldSeed()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return "UnknownSeed";
			}
			try
			{
				Type type = typeof(ZNet).Assembly.GetType("WorldGenerator");
				if (type == null)
				{
					return "UnknownSeed";
				}
				FieldInfo field = type.GetField("m_instance", BindingFlags.Static | BindingFlags.NonPublic);
				if (field == null)
				{
					return "UnknownSeed";
				}
				object value = field.GetValue(null);
				if (value == null)
				{
					return "UnknownSeed";
				}
				FieldInfo field2 = type.GetField("m_world", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field2 == null)
				{
					return "UnknownSeed";
				}
				object value2 = field2.GetValue(value);
				if (value2 == null)
				{
					return "UnknownSeed";
				}
				object obj = value2.GetType().GetField("m_seed")?.GetValue(value2);
				if (obj != null)
				{
					return obj.ToString();
				}
			}
			catch
			{
			}
			return "UnknownSeed";
		}

		private static string GetCharacterName()
		{
			try
			{
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					return Player.m_localPlayer.GetPlayerName();
				}
			}
			catch
			{
			}
			return "UnknownCharacter";
		}

		private static long GetCharacterUid()
		{
			try
			{
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					return Player.m_localPlayer.GetPlayerID();
				}
			}
			catch
			{
			}
			return 0L;
		}

		private static long GetSafeSteamId()
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				CSteamID steamID = SteamUser.GetSteamID();
				if (((CSteamID)(ref steamID)).IsValid())
				{
					return (long)(ulong)steamID;
				}
			}
			catch (Exception)
			{
			}
			try
			{
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					return Player.m_localPlayer.GetPlayerID();
				}
			}
			catch
			{
			}
			return 0L;
		}
	}
	internal static class Log
	{
		private const string Prefix = "[GCValheimStats] ";

		[Conditional("DEBUG")]
		public static void D(string msg, [CallerMemberName] string caller = "")
		{
			Debug.Log((object)("[GCValheimStats] " + caller + ": " + msg));
		}

		[Conditional("DEBUG")]
		public static void D(string msg)
		{
			Debug.Log((object)("[GCValheimStats] " + msg));
		}

		public static void W(string msg)
		{
			Debug.LogWarning((object)("[GCValheimStats] " + msg));
		}

		public static void E(string msg)
		{
			Debug.LogError((object)("[GCValheimStats] " + msg));
		}
	}
	public class ModConfig
	{
		private readonly ConfigFile Config;

		public ConfigEntry<bool> EnableMod { get; private set; }

		public ConfigEntry<int> Verbosity { get; private set; }

		public ConfigEntry<string> ApiEndpoint { get; private set; }

		public ConfigEntry<string> ApiKey { get; private set; }

		public ConfigEntry<int> SendInterval { get; private set; }

		public ConfigEntry<bool> SendOnExit { get; private set; }

		public ConfigEntry<bool> TrackCombat { get; private set; }

		public ConfigEntry<bool> TrackExploration { get; private set; }

		public ConfigEntry<bool> TrackCrafting { get; private set; }

		public ConfigEntry<bool> TrackSurvival { get; private set; }

		public ConfigEntry<bool> ShowOnScreen { get; private set; }

		public ConfigEntry<bool> ShowSendStatus { get; private set; }

		public ConfigEntry<KeyboardShortcut> ToggleStatsKey { get; private set; }

		public ConfigEntry<KeyboardShortcut> ResetStatsKey { get; private set; }

		public ConfigEntry<int> BatchInterval { get; private set; }

		public ConfigEntry<bool> EnableEncryption { get; private set; }

		public ConfigEntry<bool> EnableHmac { get; private set; }

		public ConfigEntry<int> MaxQueueSize { get; private set; }

		public ConfigEntry<int> ServerPingInterval { get; private set; }

		public ModConfig(ConfigFile config)
		{
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Expected O, but got Unknown
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: 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_021e: Expected O, but got Unknown
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Expected O, but got Unknown
			Config = config;
			EnableMod = config.Bind<bool>("General", "EnableMod", true, "Enable or disable the mod");
			Verbosity = config.Bind<int>("General", "Verbosity", 1, "Log verbosity level (0=Error, 1=Info, 2=Debug)");
			ApiEndpoint = config.Bind<string>("API", "Endpoint", "http://localhost:5000/api/batch", "Web API endpoint URL");
			ApiKey = config.Bind<string>("API", "ApiKey", "", "API key for authentication");
			SendInterval = config.Bind<int>("API", "SendInterval", 300, "Auto-send interval in seconds (0 = disabled)");
			SendOnExit = config.Bind<bool>("API", "SendOnExit", true, "Send statistics when game closes");
			TrackCombat = config.Bind<bool>("Statistics", "TrackCombat", true, "Track combat statistics");
			TrackExploration = config.Bind<bool>("Statistics", "TrackExploration", true, "Track exploration statistics");
			TrackCrafting = config.Bind<bool>("Statistics", "TrackCrafting", true, "Track crafting statistics");
			TrackSurvival = config.Bind<bool>("Statistics", "TrackSurvival", true, "Track survival statistics");
			ShowOnScreen = config.Bind<bool>("Display", "ShowOnScreen", true, "Show statistics overlay");
			ShowSendStatus = config.Bind<bool>("Display", "ShowSendStatus", true, "Show status when sending");
			ServerPingInterval = config.Bind<int>("Display", "ServerPingInterval", 30, new ConfigDescription("Server ping interval in seconds", (AcceptableValueBase)(object)new AcceptableValueRange<int>(5, 120), Array.Empty<object>()));
			ToggleStatsKey = config.Bind<KeyboardShortcut>("Keybindings", "ToggleStats", new KeyboardShortcut((KeyCode)288, Array.Empty<KeyCode>()), "Toggle stats display");
			ResetStatsKey = config.Bind<KeyboardShortcut>("Keybindings", "ResetStats", new KeyboardShortcut((KeyCode)289, (KeyCode[])(object)new KeyCode[1] { (KeyCode)306 }), "Reset stats (Ctrl+F8)");
			BatchInterval = config.Bind<int>("Batch", "Interval", 5, new ConfigDescription("Batch send interval in seconds", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 60), Array.Empty<object>()));
			EnableEncryption = config.Bind<bool>("Security", "EnableEncryption", true, "Encrypt batch files with AES-256-CBC");
			EnableHmac = config.Bind<bool>("Security", "EnableHmac", true, "Sign batches with HMAC-SHA256");
			MaxQueueSize = config.Bind<int>("Batch", "MaxQueueSize", 1000, new ConfigDescription("Maximum number of batch files in queue", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 10000), Array.Empty<object>()));
			Config.SettingChanged += OnSettingChanged;
		}

		private void OnSettingChanged(object sender, SettingChangedEventArgs args)
		{
		}
	}
	public class PlayerStats
	{
		public int playTime;

		public int maxDistance;

		public float damageDealt;

		public float damageTaken;

		public int playerKills;

		public int enemyKills;

		public int buildingBuilt;

		public int buildingBroken;

		public int portalUsed;

		public int deaths;

		public int treeChopped;

		public int mineRock;

		public int itemsPickedUp;

		public int foodConsumed;

		public int fishCaught;

		public int tamedCount;

		public int tradeCount;

		public int mapPinCount;

		public int sleepCount;

		public int skillUps;

		public float staminaUsed;

		public float hpHealed;

		public Dictionary<string, int> mobKills = new Dictionary<string, int>();

		public Dictionary<string, int> trophies = new Dictionary<string, int>();

		public PlayerStats DeepCopy()
		{
			return new PlayerStats
			{
				playTime = playTime,
				maxDistance = maxDistance,
				damageDealt = damageDealt,
				damageTaken = damageTaken,
				playerKills = playerKills,
				enemyKills = enemyKills,
				buildingBuilt = buildingBuilt,
				buildingBroken = buildingBroken,
				portalUsed = portalUsed,
				deaths = deaths,
				treeChopped = treeChopped,
				mineRock = mineRock,
				itemsPickedUp = itemsPickedUp,
				foodConsumed = foodConsumed,
				fishCaught = fishCaught,
				tamedCount = tamedCount,
				tradeCount = tradeCount,
				mapPinCount = mapPinCount,
				sleepCount = sleepCount,
				skillUps = skillUps,
				staminaUsed = staminaUsed,
				hpHealed = hpHealed,
				mobKills = new Dictionary<string, int>(mobKills),
				trophies = new Dictionary<string, int>(trophies)
			};
		}
	}
	public class DamageEvent
	{
		public string attackerName;

		public Dictionary<string, float> breakdown;

		public float healthAfter;

		public Vector3 position;

		public long timestamp;
	}
	public class TombstoneData
	{
		public List<Dictionary<string, object>> tombstoneItems;

		public List<Dictionary<string, object>> remainingItems;

		public Vector3 position;
	}
	public class StatsTracker
	{
		public static StatsTracker Instance;

		public PlayerStats lifetimeStats;

		public PlayerStats sessionStats;

		public PlayerStats previousSessionStats;

		public Player currentPlayer;

		private float previousHealth;

		private float previousStamina;

		private string currentBiome = "";

		private float _foodCheckTimer;

		private float _previousFoodCount;

		private Vector3 _lastPosition;

		private float _totalDistance;

		public TombstoneData lastTombstoneData;

		public string lastDeathCause = "Unknown";

		public string lastDeathAttacker = "none";

		private readonly List<DamageEvent> _recentDamage = new List<DamageEvent>();

		private const int MAX_RECENT_DAMAGE = 10;

		private const string OLD_KEY_MOB_KILLS = "gcsv_mobKills";

		private const string OLD_KEY_TROPHIES = "gcsv_trophies";

		public bool IsTracking => (Object)(object)currentPlayer != (Object)null;

		public StatsTracker()
		{
			Instance = this;
			lifetimeStats = new PlayerStats();
			sessionStats = new PlayerStats();
			previousSessionStats = new PlayerStats();
		}

		public void StartTracking(Player player)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			currentPlayer = player;
			sessionStats = new PlayerStats();
			lifetimeStats = new PlayerStats();
			previousHealth = ((Character)player).GetHealth();
			previousStamina = player.GetStamina();
			currentBiome = ((object)player.GetCurrentBiome()/*cast due to .constrained prefix*/).ToString();
			_previousFoodCount = GetFoodCount();
			_lastPosition = ((Component)player).transform.position;
			_totalDistance = 0f;
			StatsCollector.LoadPlayerData();
			LoadPersistentData();
		}

		public void Update()
		{
			if (!((Object)(object)currentPlayer == (Object)null) && !((Character)currentPlayer).IsDead())
			{
				UpdatePlayTime();
				UpdateMaxDistance();
				UpdateHealthStaminaUsed();
				UpdateCurrentBiome();
			}
		}

		private void UpdatePlayTime()
		{
			if (Time.timeScale != 0f)
			{
				sessionStats.playTime++;
				lifetimeStats.playTime++;
			}
		}

		private void UpdateMaxDistance()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)currentPlayer).transform.position;
			float num = Vector3.Distance(_lastPosition, position);
			_totalDistance += num;
			_lastPosition = position;
			int num2 = (int)_totalDistance;
			if (num2 > sessionStats.maxDistance)
			{
				sessionStats.maxDistance = num2;
			}
			if (num2 > lifetimeStats.maxDistance)
			{
				lifetimeStats.maxDistance = num2;
			}
		}

		private void UpdateHealthStaminaUsed()
		{
			float health = ((Character)currentPlayer).GetHealth();
			float stamina = currentPlayer.GetStamina();
			if (health > previousHealth)
			{
				float num = health - previousHealth;
				sessionStats.hpHealed += num;
				lifetimeStats.hpHealed += num;
			}
			if (stamina < previousStamina)
			{
				float num2 = previousStamina - stamina;
				sessionStats.staminaUsed += num2;
				lifetimeStats.staminaUsed += num2;
			}
			previousHealth = health;
			previousStamina = stamina;
		}

		private void UpdateCurrentBiome()
		{
			//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)
			string text = ((object)currentPlayer.GetCurrentBiome()/*cast due to .constrained prefix*/).ToString();
			if (!string.IsNullOrEmpty(text) && text != currentBiome)
			{
				currentBiome = text;
			}
		}

		private float GetFoodCount()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Invalid comparison between Unknown and I4
			if ((Object)(object)currentPlayer == (Object)null)
			{
				return 0f;
			}
			Inventory inventory = ((Humanoid)currentPlayer).GetInventory();
			if (inventory == null)
			{
				return 0f;
			}
			List<ItemData> allItems = inventory.GetAllItems();
			if (allItems == null)
			{
				return 0f;
			}
			float num = 0f;
			foreach (ItemData item in allItems)
			{
				if (item != null && item.m_shared != null && (int)item.m_shared.m_itemType == 2)
				{
					num += (float)item.m_stack;
				}
			}
			return num;
		}

		public void RecordDamageDealt(float damage)
		{
			sessionStats.damageDealt += damage;
			lifetimeStats.damageDealt += damage;
		}

		public void RecordDamageTaken(float damage)
		{
			sessionStats.damageTaken += damage;
			lifetimeStats.damageTaken += damage;
		}

		public void RecordEnemyKill(string mobId, string characterName, bool isBoss, bool isTamed, int level, string biome, string element = null)
		{
			sessionStats.enemyKills++;
			lifetimeStats.enemyKills++;
			if (!string.IsNullOrEmpty(mobId))
			{
				string key = BuildMobKey(characterName, biome, isBoss, isTamed, level, element);
				if (!sessionStats.mobKills.ContainsKey(key))
				{
					sessionStats.mobKills[key] = 0;
				}
				sessionStats.mobKills[key]++;
				if (!lifetimeStats.mobKills.ContainsKey(key))
				{
					lifetimeStats.mobKills[key] = 0;
				}
				lifetimeStats.mobKills[key]++;
				SavePersistentData();
			}
		}

		public int GetTotalKillsAcrossElements(string characterName, string biome, bool isBoss, bool isTamed, int level)
		{
			int num = 0;
			string value = (characterName ?? "Unknown") + " ";
			foreach (KeyValuePair<string, int> mobKill in sessionStats.mobKills)
			{
				if (mobKill.Key == characterName || mobKill.Key.StartsWith(value))
				{
					num += mobKill.Value;
				}
			}
			return num;
		}

		private static string BuildMobKey(string characterName, string biome, bool isBoss, bool isTamed, int level, string element = null)
		{
			List<string> list = new List<string>();
			list.Add(characterName ?? "Unknown");
			if (!string.IsNullOrEmpty(biome))
			{
				list.Add(biome);
			}
			if (isBoss)
			{
				list.Add("Boss");
			}
			if (isTamed)
			{
				list.Add("Tamed");
			}
			if (level > 1)
			{
				list.Add($"{level}*");
			}
			if (!string.IsNullOrEmpty(element))
			{
				list.Add(element);
			}
			return string.Join(" ", list);
		}

		public void RecordTrophy(string trophyName)
		{
			if (!string.IsNullOrEmpty(trophyName))
			{
				if (!sessionStats.trophies.ContainsKey(trophyName))
				{
					sessionStats.trophies[trophyName] = 0;
				}
				sessionStats.trophies[trophyName]++;
				if (!lifetimeStats.trophies.ContainsKey(trophyName))
				{
					lifetimeStats.trophies[trophyName] = 0;
				}
				lifetimeStats.trophies[trophyName]++;
				SavePersistentData();
			}
		}

		public void RecordBuilding(string pieceName)
		{
			sessionStats.buildingBuilt++;
			lifetimeStats.buildingBuilt++;
		}

		public void RecordPortalUse()
		{
			sessionStats.portalUsed++;
			lifetimeStats.portalUsed++;
		}

		public void RecordDeath(Vector3 position, string cause = "Unknown", string attacker = "none")
		{
			sessionStats.deaths++;
			lifetimeStats.deaths++;
			lastDeathCause = cause;
			lastDeathAttacker = attacker;
		}

		public void RecordTombstone(TombstoneData data)
		{
			lastTombstoneData = data;
		}

		public static string GetDeathCause(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return "Unknown";
			}
			try
			{
				if ((Object)(object)Game.instance == (Object)null)
				{
					return "Unknown";
				}
				PlayerProfile playerProfile = Game.instance.GetPlayerProfile();
				if (playerProfile == null)
				{
					return "Unknown";
				}
				FieldInfo field = typeof(PlayerProfile).GetField("m_playerStats");
				if (field == null)
				{
					return "Unknown";
				}
				object value = field.GetValue(playerProfile);
				if (value == null)
				{
					return "Unknown";
				}
				PropertyInfo property = value.GetType().GetProperty("Item");
				if (property == null)
				{
					return "Unknown";
				}
				string[] array = new string[19]
				{
					"Undefined", "Enemy", "Player", "Fall", "Drowning", "Burning", "Freezing", "Poison", "Water", "Smoke",
					"EdgeOfWorld", "Impact", "Cart", "Tree", "Self", "Structural", "Turret", "Boat", "Stalagtite"
				};
				for (int i = 0; i < array.Length; i++)
				{
					try
					{
						if (Convert.ToSingle(property.GetValue(value, new object[1] { 86 + i })) > 0f)
						{
							return array[i];
						}
					}
					catch
					{
					}
				}
			}
			catch
			{
			}
			return "Unknown";
		}

		public void RecordDamageTakenFull(float damage, string attackerName, Dictionary<string, float> breakdown, Vector3 position)
		{
			//IL_0053: 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)
			RecordDamageTaken(damage);
			DamageEvent item = new DamageEvent
			{
				attackerName = (attackerName ?? "none"),
				breakdown = (breakdown ?? new Dictionary<string, float>()),
				healthAfter = (((Object)(object)currentPlayer != (Object)null) ? ((Character)currentPlayer).GetHealth() : 0f),
				position = position,
				timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
			};
			_recentDamage.Add(item);
			if (_recentDamage.Count > 10)
			{
				_recentDamage.RemoveAt(0);
			}
		}

		public List<DamageEvent> GetRecentDamage()
		{
			return new List<DamageEvent>(_recentDamage);
		}

		public void RecordFishing(string fishName)
		{
			sessionStats.fishCaught++;
			lifetimeStats.fishCaught++;
		}

		public void RecordTaming(string creatureName)
		{
			sessionStats.tamedCount++;
			lifetimeStats.tamedCount++;
		}

		public void RecordTrade(string traderName)
		{
			sessionStats.tradeCount++;
			lifetimeStats.tradeCount++;
		}

		public void RecordMapPin(string pinType)
		{
			sessionStats.mapPinCount++;
			lifetimeStats.mapPinCount++;
		}

		public void RecordSleep()
		{
			sessionStats.sleepCount++;
			lifetimeStats.sleepCount++;
		}

		public void RecordSkillLevelUp(string skillName)
		{
			sessionStats.skillUps++;
			lifetimeStats.skillUps++;
		}

		public void RecordFoodConsumed()
		{
			sessionStats.foodConsumed++;
			lifetimeStats.foodConsumed++;
		}

		public void RecordPickup(string itemName)
		{
			sessionStats.itemsPickedUp++;
			lifetimeStats.itemsPickedUp++;
		}

		public void RecordChopping(string treeName)
		{
			sessionStats.treeChopped++;
			lifetimeStats.treeChopped++;
		}

		public void RecordMining(string rockName)
		{
			sessionStats.mineRock++;
			lifetimeStats.mineRock++;
		}

		public void ResetSession()
		{
			sessionStats = new PlayerStats();
		}

		public void SaveStats()
		{
			SavePersistentData();
			previousSessionStats = sessionStats.DeepCopy();
		}

		public void LoadFromData(PlayerStats stats)
		{
			lifetimeStats = stats.DeepCopy();
		}

		private static string GetKey(string baseKey)
		{
			Player localPlayer = Player.m_localPlayer;
			long num = ((localPlayer != null) ? localPlayer.GetPlayerID() : 0);
			return $"gcsv_{num}_{baseKey}";
		}

		public void SavePersistentData()
		{
			try
			{
				if (!((Object)(object)Player.m_localPlayer == (Object)null))
				{
					Dictionary<string, string> customData = Player.m_localPlayer.m_customData;
					if (customData != null)
					{
						customData[GetKey("playTime")] = sessionStats.playTime.ToString();
						customData[GetKey("maxDistance")] = sessionStats.maxDistance.ToString();
						customData[GetKey("damageDealt")] = sessionStats.damageDealt.ToString("F1");
						customData[GetKey("damageTaken")] = sessionStats.damageTaken.ToString("F1");
						customData[GetKey("enemyKills")] = sessionStats.enemyKills.ToString();
						customData[GetKey("playerKills")] = sessionStats.playerKills.ToString();
						customData[GetKey("deaths")] = sessionStats.deaths.ToString();
						customData[GetKey("buildingBuilt")] = sessionStats.buildingBuilt.ToString();
						customData[GetKey("buildingBroken")] = sessionStats.buildingBroken.ToString();
						customData[GetKey("treeChopped")] = sessionStats.treeChopped.ToString();
						customData[GetKey("mineRock")] = sessionStats.mineRock.ToString();
						customData[GetKey("itemsPickedUp")] = sessionStats.itemsPickedUp.ToString();
						customData[GetKey("foodConsumed")] = sessionStats.foodConsumed.ToString();
						customData[GetKey("fishCaught")] = sessionStats.fishCaught.ToString();
						customData[GetKey("tamedCount")] = sessionStats.tamedCount.ToString();
						customData[GetKey("tradeCount")] = sessionStats.tradeCount.ToString();
						customData[GetKey("portalUsed")] = sessionStats.portalUsed.ToString();
						customData[GetKey("sleepCount")] = sessionStats.sleepCount.ToString();
						customData[GetKey("skillUps")] = sessionStats.skillUps.ToString();
						customData[GetKey("staminaUsed")] = sessionStats.staminaUsed.ToString("F1");
						customData[GetKey("hpHealed")] = sessionStats.hpHealed.ToString("F1");
						customData[GetKey("mobKills")] = DictToKV(sessionStats.mobKills);
						customData[GetKey("trophies")] = DictToKV(sessionStats.trophies);
					}
				}
			}
			catch (Exception ex)
			{
				Log.W("SavePersistentData failed: " + ex.Message);
			}
		}

		public void LoadPersistentData()
		{
			try
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					return;
				}
				Dictionary<string, string> customData = Player.m_localPlayer.m_customData;
				if (customData != null)
				{
					MigrateOldKey(customData, "gcsv_mobKills", GetKey("mobKills"));
					MigrateOldKey(customData, "gcsv_trophies", GetKey("trophies"));
					if (customData.TryGetValue(GetKey("playTime"), out var value) && int.TryParse(value, out var result))
					{
						sessionStats.playTime = result;
					}
					if (customData.TryGetValue(GetKey("maxDistance"), out var value2) && int.TryParse(value2, out var result2))
					{
						sessionStats.maxDistance = result2;
					}
					if (customData.TryGetValue(GetKey("damageDealt"), out var value3) && float.TryParse(value3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
					{
						sessionStats.damageDealt = result3;
					}
					if (customData.TryGetValue(GetKey("damageTaken"), out var value4) && float.TryParse(value4, NumberStyles.Float, CultureInfo.InvariantCulture, out var result4))
					{
						sessionStats.damageTaken = result4;
					}
					if (customData.TryGetValue(GetKey("enemyKills"), out var value5) && int.TryParse(value5, out var result5))
					{
						sessionStats.enemyKills = result5;
					}
					if (customData.TryGetValue(GetKey("playerKills"), out var value6) && int.TryParse(value6, out var result6))
					{
						sessionStats.playerKills = result6;
					}
					if (customData.TryGetValue(GetKey("deaths"), out var value7) && int.TryParse(value7, out var result7))
					{
						sessionStats.deaths = result7;
					}
					if (customData.TryGetValue(GetKey("buildingBuilt"), out var value8) && int.TryParse(value8, out var result8))
					{
						sessionStats.buildingBuilt = result8;
					}
					if (customData.TryGetValue(GetKey("buildingBroken"), out var value9) && int.TryParse(value9, out var result9))
					{
						sessionStats.buildingBroken = result9;
					}
					if (customData.TryGetValue(GetKey("treeChopped"), out var value10) && int.TryParse(value10, out var result10))
					{
						sessionStats.treeChopped = result10;
					}
					if (customData.TryGetValue(GetKey("mineRock"), out var value11) && int.TryParse(value11, out var result11))
					{
						sessionStats.mineRock = result11;
					}
					if (customData.TryGetValue(GetKey("itemsPickedUp"), out var value12) && int.TryParse(value12, out var result12))
					{
						sessionStats.itemsPickedUp = result12;
					}
					if (customData.TryGetValue(GetKey("foodConsumed"), out var value13) && int.TryParse(value13, out var result13))
					{
						sessionStats.foodConsumed = result13;
					}
					if (customData.TryGetValue(GetKey("fishCaught"), out var value14) && int.TryParse(value14, out var result14))
					{
						sessionStats.fishCaught = result14;
					}
					if (customData.TryGetValue(GetKey("tamedCount"), out var value15) && int.TryParse(value15, out var result15))
					{
						sessionStats.tamedCount = result15;
					}
					if (customData.TryGetValue(GetKey("tradeCount"), out var value16) && int.TryParse(value16, out var result16))
					{
						sessionStats.tradeCount = result16;
					}
					if (customData.TryGetValue(GetKey("portalUsed"), out var value17) && int.TryParse(value17, out var result17))
					{
						sessionStats.portalUsed = result17;
					}
					if (customData.TryGetValue(GetKey("sleepCount"), out var value18) && int.TryParse(value18, out var result18))
					{
						sessionStats.sleepCount = result18;
					}
					if (customData.TryGetValue(GetKey("skillUps"), out var value19) && int.TryParse(value19, out var result19))
					{
						sessionStats.skillUps = result19;
					}
					if (customData.TryGetValue(GetKey("staminaUsed"), out var value20) && float.TryParse(value20, NumberStyles.Float, CultureInfo.InvariantCulture, out var result20))
					{
						sessionStats.staminaUsed = result20;
					}
					if (customData.TryGetValue(GetKey("hpHealed"), out var value21) && float.TryParse(value21, NumberStyles.Float, CultureInfo.InvariantCulture, out var result21))
					{
						sessionStats.hpHealed = result21;
					}
					if (customData.TryGetValue(GetKey("mobKills"), out var value22) && !string.IsNullOrEmpty(value22))
					{
						KVToDict(value22, sessionStats.mobKills);
					}
					if (customData.TryGetValue(GetKey("trophies"), out var value23) && !string.IsNullOrEmpty(value23))
					{
						KVToDict(value23, sessionStats.trophies);
					}
				}
			}
			catch (Exception ex)
			{
				Log.W("LoadPersistentData failed: " + ex.Message);
			}
		}

		private static void MigrateOldKey(Dictionary<string, string> cd, string oldKey, string newKey)
		{
			if (cd.TryGetValue(oldKey, out string value) && !string.IsNullOrEmpty(value))
			{
				if (!cd.ContainsKey(newKey))
				{
					cd[newKey] = value;
				}
				cd.Remove(oldKey);
			}
		}

		private static string DictToKV(Dictionary<string, int> dict)
		{
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, int> item in dict)
			{
				list.Add(string.Format("{0}={1}", item.Key.Replace("=", "\\="), item.Value));
			}
			return string.Join(";", list);
		}

		private static void KVToDict(string str, Dictionary<string, int> dict)
		{
			dict.Clear();
			if (string.IsNullOrEmpty(str))
			{
				return;
			}
			string[] array = str.Split(new char[1] { ';' });
			foreach (string text in array)
			{
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				int num = text.LastIndexOf('=');
				if (num >= 0)
				{
					string key = text.Substring(0, num).Replace("\\=", "=");
					if (int.TryParse(text.Substring(num + 1), out var result))
					{
						dict[key] = result;
					}
				}
			}
		}
	}
	public class StatsCollector
	{
		public static void LoadPlayerData()
		{
			try
			{
				if ((Object)(object)Game.instance == (Object)null || Game.instance.GetPlayerProfile() == null)
				{
					return;
				}
				Dictionary<string, float> historicalStats = GetHistoricalStats(Player.m_localPlayer);
				if (historicalStats == null || StatsTracker.Instance == null)
				{
					return;
				}
				PlayerStats playerStats = new PlayerStats();
				foreach (KeyValuePair<string, float> item in historicalStats)
				{
					switch (item.Key)
					{
					case "Deaths":
						playerStats.deaths = (int)item.Value;
						break;
					case "Builds":
						playerStats.buildingBuilt = (int)item.Value;
						break;
					case "Kills":
						playerStats.enemyKills = (int)item.Value;
						break;
					case "Trees_Cut":
						playerStats.treeChopped = (int)item.Value;
						break;
					case "Distance_Total":
						playerStats.maxDistance = (int)item.Value;
						break;
					}
				}
				StatsTracker.Instance.LoadFromData(playerStats);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[GCValheimStats] LoadPlayerData failed: " + ex.Message));
			}
		}

		public static object CollectFullPlayerStats(Player player)
		{
			//IL_0036: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			long playerID = player.GetPlayerID();
			string playerName = player.GetPlayerName();
			long timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			float health = ((Character)player).GetHealth();
			float maxHealth = ((Character)player).GetMaxHealth();
			var position = new
			{
				((Component)player).transform.position.x,
				((Component)player).transform.position.y,
				((Component)player).transform.position.z
			};
			string? current_biome = ((object)player.GetCurrentBiome()/*cast due to .constrained prefix*/).ToString();
			Inventory inventory = ((Humanoid)player).GetInventory();
			return new
			{
				player_id = playerID,
				player_name = playerName,
				timestamp = timestamp,
				health = health,
				max_health = maxHealth,
				position = position,
				current_biome = current_biome,
				inventory_weight = ((inventory != null) ? inventory.GetTotalWeight() : 0f),
				max_carry_weight = player.GetMaxCarryWeight(),
				equipment = new
				{
					right_hand = GetItemInfo(GetPrivateField<ItemData>(player, "m_rightItem")),
					left_hand = GetItemInfo(GetPrivateField<ItemData>(player, "m_leftItem")),
					chest = GetItemInfo(GetPrivateField<ItemData>(player, "m_chestItem")),
					legs = GetItemInfo(GetPrivateField<ItemData>(player, "m_legItem")),
					helmet = GetItemInfo(GetPrivateField<ItemData>(player, "m_helmetItem")),
					shoulder = GetItemInfo(GetPrivateField<ItemData>(player, "m_shoulderItem")),
					utility = GetItemInfo(GetPrivateField<ItemData>(player, "m_utilityItem")),
					trinket = GetItemInfo(GetPrivateField<ItemData>(player, "m_trinketItem")),
					ammo = GetItemInfo(GetPrivateField<ItemData>(player, "m_ammoItem"))
				},
				stamina = player.GetStamina(),
				max_stamina = ((Character)player).GetMaxStamina(),
				eitr = player.GetEitr(),
				max_eitr = ((Character)player).GetMaxEitr(),
				active_foods = GetActiveFoods(player),
				top_skills = GetTopSkills(player),
				historical_stats = GetHistoricalStats(player)
			};
		}

		private static T GetPrivateField<T>(object obj, string fieldName) where T : class
		{
			if (obj == null)
			{
				return null;
			}
			return obj.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(obj) as T;
		}

		private static object GetItemInfo(ItemData item)
		{
			if (item == null)
			{
				return null;
			}
			return new
			{
				name = item.m_shared.m_name,
				quality = item.m_quality,
				durability = item.m_durability,
				max_durability = item.GetMaxDurability(),
				weight = item.m_shared.m_weight,
				value = item.m_shared.m_value,
				stack = item.m_stack,
				max_stack = item.m_shared.m_maxStackSize,
				type = ((object)Unsafe.As<ItemType, ItemType>(ref item.m_shared.m_itemType)/*cast due to .constrained prefix*/).ToString(),
				skill = ((object)Unsafe.As<SkillType, SkillType>(ref item.m_shared.m_skillType)/*cast due to .constrained prefix*/).ToString(),
				block_power = item.m_shared.m_blockPower,
				deflection_force = item.m_shared.m_deflectionForce,
				timed_block_bonus = item.m_shared.m_timedBlockBonus,
				movement_modifier = item.m_shared.m_movementModifier,
				jump_stamina_modifier = item.m_shared.m_jumpStaminaModifier,
				attack_stamina_modifier = item.m_shared.m_attackStaminaModifier,
				block_stamina_modifier = item.m_shared.m_blockStaminaModifier,
				dodge_stamina_modifier = item.m_shared.m_dodgeStaminaModifier
			};
		}

		private static List<object> GetActiveFoods(Player player)
		{
			List<object> list = new List<object>();
			IList privateField = GetPrivateField<IList>(player, "m_foods");
			if (privateField == null)
			{
				return list;
			}
			foreach (object item in privateField)
			{
				if (item == null)
				{
					continue;
				}
				try
				{
					object? obj = item.GetType().GetField("m_item")?.GetValue(item);
					ItemDrop val = (ItemDrop)((obj is ItemDrop) ? obj : null);
					float remaining_time = Convert.ToSingle(item.GetType().GetField("m_time")?.GetValue(item) ?? ((object)0f));
					float health = Convert.ToSingle(item.GetType().GetField("m_health")?.GetValue(item) ?? ((object)0f));
					float stamina = Convert.ToSingle(item.GetType().GetField("m_stamina")?.GetValue(item) ?? ((object)0f));
					float eitr = Convert.ToSingle(item.GetType().GetField("m_eitr")?.GetValue(item) ?? ((object)0f));
					if (val?.m_itemData?.m_shared != null)
					{
						list.Add(new
						{
							name = val.m_itemData.m_shared.m_name,
							remaining_time = remaining_time,
							health = health,
							stamina = stamina,
							eitr = eitr
						});
					}
				}
				catch
				{
				}
			}
			return list;
		}

		private static List<object> GetTopSkills(Player player)
		{
			List<object> list = new List<object>();
			Skills privateField = GetPrivateField<Skills>(player, "m_skills");
			if ((Object)(object)privateField == (Object)null)
			{
				return list;
			}
			List<Skill> skillList = privateField.GetSkillList();
			if (skillList == null)
			{
				return list;
			}
			foreach (Skill item in (from s in skillList
				where s != null && s.m_level > 0f
				orderby s.m_level descending
				select s).Take(5))
			{
				float level = item.m_level;
				float progress = 0f;
				try
				{
					MethodInfo method = ((object)item).GetType().GetMethod("GetNextLevelRequirement");
					if (method != null)
					{
						float num = Convert.ToSingle(method.Invoke(item, null));
						if (num > 0f)
						{
							progress = item.m_accumulator / num;
						}
					}
				}
				catch
				{
				}
				list.Add(new
				{
					name = ((object)Unsafe.As<SkillType, SkillType>(ref item.m_info.m_skill)/*cast due to .constrained prefix*/).ToString(),
					level = level,
					progress = progress
				});
			}
			return list;
		}

		private static Dictionary<string, float> GetHistoricalStats(Player player)
		{
			Dictionary<string, float> stats = new Dictionary<string, float>();
			try
			{
				if ((Object)(object)Game.instance == (Object)null)
				{
					return stats;
				}
				PlayerProfile playerProfile = Game.instance.GetPlayerProfile();
				if (playerProfile == null)
				{
					return stats;
				}
				FieldInfo field = typeof(PlayerProfile).GetField("m_playerStats");
				if (field == null)
				{
					return stats;
				}
				object playerStats = field.GetValue(playerProfile);
				if (playerStats == null)
				{
					return stats;
				}
				PropertyInfo indexer = playerStats.GetType().GetProperty("Item");
				if (indexer == null)
				{
					return stats;
				}
				AddStat("deaths", GetStat(0));
				AddStat("crafts", GetStat(1));
				AddStat("builds", GetStat(2));
				AddStat("jumps", GetStat(3));
				AddStat("hits", GetStat(5));
				AddStat("kills", GetStat(6));
				AddStat("pvp_hits", GetStat(8));
				AddStat("pvp_kills", GetStat(9));
				AddStat("hits_taken", GetStat(10));
				AddStat("items_picked_up", GetStat(12));
				AddStat("portals", GetStat(15));
				AddStat("distance_total", GetStat(16));
				AddStat("distance_walked", GetStat(17));
				AddStat("distance_run", GetStat(18));
				AddStat("distance_sailed", GetStat(19));
				AddStat("distance_air", GetStat(20));
				AddStat("time_in_base", GetStat(21));
				AddStat("time_out_base", GetStat(22));
				AddStat("sleep_time", GetStat(23));
				AddStat("world_loads", GetStat(26));
				AddStat("trees_cut", GetStat(27));
				AddStat("mines", GetStat(37));
				AddStat("food_eaten", GetStat(49));
				AddStat("arrows_shot", GetStat(51));
				AddStat("doors_opened", GetStat(74));
				AddStat("bees_harvested", GetStat(76));
				AddStat("bosses_killed", GetStat(85));
				AddStat("death_undefined", GetStat(86));
				AddStat("death_enemy", GetStat(87));
				AddStat("death_player", GetStat(88));
				AddStat("death_fall", GetStat(89));
				AddStat("death_drowning", GetStat(90));
				AddStat("death_burning", GetStat(91));
				AddStat("death_freezing", GetStat(92));
				AddStat("death_poison", GetStat(93));
				AddStat("death_water", GetStat(94));
				AddStat("death_smoke", GetStat(95));
				AddStat("death_edge_of_world", GetStat(96));
				AddStat("death_impact", GetStat(97));
				AddStat("death_cart", GetStat(98));
				AddStat("death_tree", GetStat(99));
				AddStat("death_self", GetStat(100));
				AddStat("death_structural", GetStat(101));
				AddStat("death_turret", GetStat(102));
				AddStat("death_boat", GetStat(103));
				AddStat("death_stalagtite", GetStat(104));
				AddStat("guardian_power_use_total", GetStat(105));
				AddStat("power_eikthyr_use", GetStat(106));
				AddStat("power_elder_use", GetStat(107));
				AddStat("power_bonemass_use", GetStat(108));
				AddStat("power_moder_use", GetStat(109));
				AddStat("power_yagluth_use", GetStat(110));
				AddStat("power_queen_use", GetStat(111));
				AddStat("power_ashlands_use", GetStat(112));
				AddStat("power_deep_north_use", GetStat(113));
				float GetStat(int index)
				{
					try
					{
						return Convert.ToSingle(indexer.GetValue(playerStats, new object[1] { index }));
					}
					catch
					{
						return 0f;
					}
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[GCValheimStats] Error getting historical stats: " + ex.Message));
			}
			return stats;
			void AddStat(string key, float value)
			{
				stats[key] = value;
			}
		}
	}
	public static class ActivityLogger
	{
		private static string _playerName = "";

		private static long _playerID;

		private static string _steamId = "";

		public static void Initialize(string playerName, long playerID)
		{
			_playerName = playerName;
			_playerID = playerID;
			_steamId = playerID.ToString();
		}

		public static string GetSteamId()
		{
			return _steamId;
		}

		public static string FormatEvent(string eventName, string parameters = "")
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return null;
			}
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			string text = $"({position.x:0.0} {position.y:0.0} {position.z:0.0})";
			string text2 = DateTime.UtcNow.ToString("G", CultureInfo.InvariantCulture);
			if (string.IsNullOrEmpty(parameters))
			{
				return "[" + text2 + "] " + _steamId + " " + text + " " + eventName;
			}
			return "[" + text2 + "] " + _steamId + " " + text + " " + eventName + " " + parameters;
		}

		public static string FormatEventPosition(string eventName, Vector3 position, string parameters = "")
		{
			//IL_0005: 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_001b: Unknown result type (might be due to invalid IL or missing references)
			string text = $"({position.x:0.0} {position.y:0.0} {position.z:0.0})";
			string text2 = DateTime.UtcNow.ToString("G", CultureInfo.InvariantCulture);
			if (string.IsNullOrEmpty(parameters))
			{
				return "[" + text2 + "] " + _steamId + " " + text + " " + eventName;
			}
			return "[" + text2 + "] " + _steamId + " " + text + " " + eventName + " " + parameters;
		}

		public static string FormatPlayer()
		{
			return $"{_playerName}({_playerID})";
		}

		public static string FormatItem(ItemData item, int amount = 1)
		{
			if (item == null)
			{
				return "null";
			}
			string text = item.m_shared?.m_name ?? "Unknown";
			string text2 = "";
			if (item.m_crafterID != 0L)
			{
				text2 = $" crafter:{item.m_crafterName}({item.m_crafterID})";
			}
			string text3 = "";
			if (item.m_customData != null && item.m_customData.Count > 0)
			{
				StringBuilder stringBuilder = new StringBuilder(" data:");
				foreach (KeyValuePair<string, string> customDatum in item.m_customData)
				{
					stringBuilder.Append("[" + customDatum.Key + "]:[" + customDatum.Value + "]");
				}
				text3 = stringBuilder.ToString();
			}
			return $"{text} x{amount} quality:{item.m_quality}{text2}{text3}";
		}

		public static string FormatDamage(HitData hit)
		{
			//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_002c: 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_0048: 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_0064: 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_0080: 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_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)
			if (hit == null)
			{
				return "";
			}
			DamageTypes damage = hit.m_damage;
			return $"damage:{hit.GetTotalDamage():0.0} blunt:{damage.m_blunt:0.0} slash:{damage.m_slash:0.0} pierce:{damage.m_pierce:0.0} fire:{damage.m_fire:0.0} frost:{damage.m_frost:0.0} lightning:{damage.m_lightning:0.0} poison:{damage.m_poison:0.0} spirit:{damage.m_spirit:0.0} chop:{damage.m_chop:0.0} pickaxe:{damage.m_pickaxe:0.0}";
		}

		public static string FormatItemContainer(Inventory inv, string containerName)
		{
			if (inv == null)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine(containerName);
			List<ItemData> allItems = inv.GetAllItems();
			if (allItems != null)
			{
				foreach (ItemData item in allItems)
				{
					if (item != null)
					{
						stringBuilder.AppendLine(FormatItem(item));
					}
				}
			}
			return stringBuilder.ToString();
		}

		public static void SendEvent(string logLine)
		{
			//IL_009f: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(logLine))
			{
				return;
			}
			try
			{
				StatsWebClient.Instance.SendLogEvent(logLine);
			}
			catch (Exception ex)
			{
				Log.E("SendEvent failed: " + ex.Message);
			}
			try
			{
				if (GCValheimStatsPlugin.EventQueue != null && (Object)(object)Player.m_localPlayer != (Object)null)
				{
					EventEntry entry = new EventEntry
					{
						Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
						EventType = ExtractEventType(logLine),
						Parameters = new Dictionary<string, object> { ["raw"] = logLine },
						Position = new float[3]
						{
							((Component)Player.m_localPlayer).transform.position.x,
							((Component)Player.m_localPlayer).transform.position.y,
							((Component)Player.m_localPlayer).transform.position.z
						}
					};
					GCValheimStatsPlugin.EventQueue.Enqueue(entry);
				}
			}
			catch
			{
			}
		}

		private static string ExtractEventType(string logLine)
		{
			if (string.IsNullOrEmpty(logLine))
			{
				return "unknown";
			}
			int num = logLine.LastIndexOf(' ');
			if (num >= 0 && num < logLine.Length - 1)
			{
				return logLine.Substring(num + 1).Split(new char[1] { ' ' })[0];
			}
			return "unknown";
		}
	}
	public static class GracefulDegradation
	{
		public static (byte[] aesKey, byte[] hmacKey) SafeDeriveKey(long steamId)
		{
			try
			{
				return KeyDeriver.DeriveKey(steamId);
			}
			catch (Exception ex)
			{
				Log.W("Key derivation failed: " + ex.Message + ". Running without encryption.");
				return (aesKey: null, hmacKey: null);
			}
		}

		public static void SafeSaveBatch(QueueStorage storage, BatchData batch, byte[] aesKey, byte[] hmacKey)
		{
			try
			{
				if (aesKey != null && hmacKey != null)
				{
					storage.SaveBatch(batch, aesKey, hmacKey);
				}
				else
				{
					SaveBatchUnencrypted(storage, batch);
				}
			}
			catch (Exception ex)
			{
				Log.W("Failed to save batch: " + ex.Message);
			}
		}

		public static async Task<int> SafeSendAll(BatchSender sender, byte[] aesKey, byte[] hmacKey)
		{
			try
			{
				return await sender.SendAllPending(aesKey, hmacKey);
			}
			catch (Exception ex)
			{
				Log.W("Send failed: " + ex.Message);
				return 0;
			}
		}

		public static string GetSafeSteamId()
		{
			try
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					return "local";
				}
				return Player.m_localPlayer.GetPlayerID().ToString();
			}
			catch
			{
				return "local";
			}
		}

		private static void SaveBatchUnencrypted(QueueStorage storage, BatchData batch)
		{
			try
			{
				string contents = batch.ToJson();
				string path = Path.Combine(Path.GetDirectoryName(typeof(QueueStorage).Assembly.Location), "queue", batch.BatchId + ".json");
				Directory.CreateDirectory(Path.GetDirectoryName(path));
				File.WriteAllText(path, contents);
			}
			catch (Exception ex)
			{
				Log.W("Unencrypted save also failed: " + ex.Message);
			}
		}
	}
	public static class MobIcons
	{
		public const int IconSize = 32;

		public const int TrophySize = 32;

		public static readonly string[] OrderedNames = new string[66]
		{
			"Boar", "Deer", "Neck", "Greyling", "Eikthyr", "Greydwarf", "Greydwarf Brute", "Greydwarf Shaman", "Rancid Remains", "Skeleton",
			"Ghost", "Troll", "Bear", "Brenna", "The Elder", "Serpent", "Abomination", "Blob", "Oozer", "Draugr",
			"Draugr Elite", "Leech", "Surtling", "Wraith", "Kvastur", "Bonemass", "Wolf", "Drake", "Fenring", "Stone Golem",
			"Bat", "Ulv", "Cultist", "Geirrhafa", "Moder", "Deathsquito", "Fuling", "Fuling Berserker", "Fuling Shaman", "Growth",
			"Lox", "Vile", "Zil", "Thunder", "Yagluth", "Hare", "Seeker", "Seeker Soldier", "Seeker Brood", "Tick",
			"Gjall", "Dvergr Rogue", "Dvergr Mage", "The Queen", "Bonemaw", "Lava Blob", "Fallen Valkyrie", "Charred Warlock", "Charred Warrior", "Charred Marksman",
			"Charred Twitcher", "Volture", "Morgen", "Asksvin", "Lord Reto", "Fader"
		};

		public static readonly Dictionary<string, string> Icons = new Dictionary<string, string>
		{
			["Boar"] = "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",
			["Deer"] = "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",
			["Neck"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFSMjJNbgvDLM1KoeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsFWwAFAckIEQjbn6aOS+LqyWSps4N6i4RWqFxjPZI0TzQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAE8pNxz/VF8//4mTZf+9xo+60t2qmaa0e+mlqHf/aHpP/wgdBpIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACHjGIxrLaGtsvQmf3S15P70NmN/s/alf/O3Zb/w9GP/7bDi/mMoHD9UmZOuQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv7aQPMW6hevWzY7/2ted/t3Zlf/LyYX/1tmk/dLZmvvEy4D+tcN3/6q8ef2muYr7mKuKXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC7qIiU6M+s/8avhPnRvoz/2sKZ/8myg//PvY7/u6p4/7ewaf+utWj/oLFl/pauZP+kuYPtjp1/IgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANq/n5jz3LH94dGY++jeo//PzKL/uraL/8m5hf+woGP/srFs/7jBeP+qvnH/nLVk/qC0c/81RTHXAAsALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhH9cYHKCVv96kF77dI1f/jZTLv8hOBX/ZnRE/52rZ/+So2L/kqZj/5uxaf+XrmL/pbl9/DdHM/8AAgDLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFVNBjAxIP/8COiv+AB8U/AEhEv8hUjD/Tn1J/16CS/9ohkv/hJxZ/5GlXv+HmGL+a4Be/AMPBvwNFBFKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHFFRdBA+N/UFKib/Ay8i/BZMNv8TTjL/NGY6/12FT/9ujE//nbFs/4ebXf6DnGf9QVU67AAAAFMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVFMMg86OJEMNjL/BTQq/wA3K/8IOij/KVw5/1SETf93mVX/f5pX/m6RUP6ovoDx0+KlRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCokKhU8OsECMC37ADMs/wg5L/8bVD3/WI9g/3GaV/9zkk//aJBT/oymY//C05L/uMeChWV4QHuRoGYjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIxVeM2BWShFGP/YCMCv+DT8q/hpSPf8pXjf/Z5BM/4mpZf96oWX/TG05/m6GUP/T56H/vMuG+6WzdNU9ZkcZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKj8qDCtJMzs9blrGEEU6/Q9AN/shVDv/H1hA/ytgOv92n2H/j69n/4OpZf84Yjr/AhkG/1NxQv6zyYP8w82G/4mfcrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVIBfix1LM/8JNy7/FElC/x5SPP4eWDf/OG5E/3ScZ/+RsGz/dpxg/xpKLv8AHxH/CiQQ/zhUKP6tu3L9nq93/ys+NDUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTNhnJUeUz6AisW/xc8NbkbS0beGVZD/y9hP/0oVzH/U3lO/4uqa/94nGT/Kl03/wEwFf8jSDf/MVY8/nmSU/+3xYLsKjgqEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApq1uRbvDfyIAAAAAAAAAAAAAAADf6pyUvM+H/zpjPP8AHg2nAAAAACFQSzYISDnsN2tK/0FqPv5aglD/gJ9h/4qqcP9hi1X/MmAv/y1WNP8jSS7+WHVG/c7el/u6x4ZKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMbGlxucpXWqjaRp763If0L///8O3ey5vKG/gP84XTPyBi4XmxkAAAoAAAAAAAAAAAZENE4bVTb6XIdM/mOMS/5wllf/i6xs/4akYf+Cnlr/a49S/0trP/89Uiz9w9WT/52vdOhQYT88AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAp69/IK26jY1ae1DUTHZL8pSxhN9ceFnyAS8TkAAFAC0AAAAAAAAAAAAAAAAAAAAAAAAAAAtGJ5VMfUb/aJBN+1+ISf95n1z/jKpg/5q1Z/+JqFz/hp1h/2FyQ/+huH3+gqFw/01tRdl6l2cbAAAAAAAAAAAAAAAAAAAAAAAAAACFi1wslJtxJAASEg4eTEBTI0w8iAAAACIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEAmfiVdOP9sjlf7T3k6/1yIRP+AqGL/cpdO/4ejWv+To17/fY1I/4WfZP94nXX8PmRG/3aUZr1cc1EWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIRyt6EE43/0dsSvtZg0j/QnE3/12LUf9ijEj/YH43/4ucUP+puWz/jKJg/4mie/9KaVf8dZVw/3eRZd5nZz8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVV8qGCBII54cTzT/IUgw/EhwQP87ajz/KFcq/0FnMv9oiEf/scV2/7LBdv+rvnf/laZ//0VhTf9RdFz9iah9/6rAjuqjvoizFUUlYAAuAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGnYFqfoF/dfYVM/0dfMf8fRCD/KE0q/zBdOv8oVjf/GDoe/3WUYf/R5Zr/tcN3/63DfP90lGj/SW5a/iZRPPs7aEb6U3xX/1+IYf82aFP/CTcnhgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1t2hkq6th/6ymZf+ln1r8eoRE/zdZJv81WjT/FUAt/ws0Kv8NLhz/Pls2/7vPh/+9y37/rcR+/2iPYP9Jb13/JVNG/xNIMP8ZRDT5JlJB3ydOR68KLClKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxtmXG5mhW/WWmlL+pqti/Z6nW/6Ro1r9aopL/0huQ/8NNyH/CjQp/wkqIP8gPSX/qrx4/8LPgf+Wq2b9VHtM/kdmWNU2W1ZwJFZGUzJbVjhPd28gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC8zX+Cz+OTnNviqEeqtHeTq7Ru/4OSVP1gdEL2V25F+0pnOv9Kbz36S3JK+yRPNv0MNS39DC4r+xEwG/2Np2T/xdaK/4SWVfxUdU3/Q2BMagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKa6azSwxnGzzNaT/cfPjfvDy4b7SWE1/wAPAKoYNDRJCise4A44IP8vXz3/KldD/xA6Nf8KMzL/DTEc/2+QU/7I4JT8k6hm/1JuS8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKq8fH+csXP/u9GK/5iqafwgPRz8ABQHZgAAAAA0Vz0dDjEgfA06I6cXSC/GFkQ31Ao3NY8LLR1xRWc7+7bSg/2RqmD/R2k9aAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkattOjBeNWlOdD64h55f9o+qaf9fdD+1AAAAAAAAAAAAAAAAAAAAABcuLgseSzwRAAAAAAAAAAAdQxvJg6NZ/4egVvxJbDvNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgeUI9n7tyqrDJe/+Bl1aKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjAE5NbjP7iqRe/XSQWv+cr3vH3OagSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAk6pcRYujYMNti01WAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAm7p8Un+gaf9xkVzwRVo31WN5Ud6twn70t8Z/nsnWhhMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF6ERjYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACds2ufbpBUkR1EJzQAAAAVAAAADT9hKjydr21wvc2DHwAAAAAAAAAAAAAAAA==",
			["Greyling"] = "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",
			["Eikthyr"] = "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",
			["Greydwarf"] = "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",
			["Greydwarf Brute"] = "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",
			["Greydwarf Shaman"] = "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",
			["Rancid Remains"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPIk8Q43Hd1wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEaZXkEZdyL2WqRF/8PjoIEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK4FIghxqKf8fVxf+dJhasQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUaihlDFEZ/x1CGP48ZCuYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAc8DyILXhXgNXIs+32WXUcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJxHV4OVhrgAAAAAAAAAAAqaiMkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABRiGlgwezV4Ay8VgAAyDukLUxifEEwWxRNAEO5OeTwqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALDXdQ3D6Gki4v9nNub5aojp/2YjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEwNqxBMEP8MPhX/CTIP9wZIEMgANAn8GEgWz2GnTWMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6f9/JOr6hLHt/43K8/yW7ebzidvq8IBXAAAAAAAAAAAAAAAAAAAAAAAAAAAZkiJ2FF0Osg1IFu0JOBjxBTsMvQhZD9gVdxteKZErjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMbPQhvu+HV+9f+h3uf1reHf8rfw8/a5//P4of/t9Yij4v9jEgAAAAAAAAAAAAAAACSnKZgdgyKVDF0WoQQ6DNoGQw2cI4ojdDCZLD8jly55PKA3MwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5+5fbu/4gOf1/8bujKd573qgZfT2/9b59/zP9/L7mf3n/HdgAAAAAAAAAAANYA0lIIIcsiGSK2oFXhizB0cQ7wZOFL8heyGn5/+iCwt0HFoUYRaiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADt+nus8v+V8qnJkOYUORf3Di8R/1qMSvje9r33+P+u59z/f2YAAAAAAAAAADGZKHE2jiJCEIEejgmCIXEJVhK9CFIYjxZ5Im8AAAAAAEwAFEaHPY0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4OpiS+fxeOPr9Znw9/vT+W+OavIZQA/9S5Yt/ZDPbPrL6IXt0PZ0jgAAAAAAAAAAMKIwdAAAAAAuoUg8M6VZFAM9CN0XVhyjJnQmOwAAAAAAAAAAf9tmUH/fbxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADh6Vcj4vBuWur4jKP//9T8w9mv8cDgovXE55n45vvA98zoj/CCqD/cU3AvgUFuOnEfZh9IAAAAAEa5QWYwhiStAi4C/R9GG6n//7sPAAAAAAAAAABGhDJmVYMuIQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5v+IdO78pPj0/cf9+vvW+/j60Pr4/8z/8v+m8dLocVEcOA5IMlQg6CxaHn8AAAAAO7E5gB1sFv8NQgvEHFQY44e0aREAAAAAAAAAACVZGnVPbztwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADn/5or6v+YpPH5nV7496jh8/mp/e38nqzn+5VN7P+NGwAAAAAWUBBPFFMQPQAAAAAASAJYF14Z7RdmHqEMRQqxAAAAAAAAAAArkTojK3kvOzVfMqFjf2MSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO/7e0Do+nFnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhuHMYzdDB4ADQCfk6GLOfg/5ohAAAAAEijSA4TcCZCFFwYcQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcxEsG4UptwAAAAAGlxslR6cxwwAAAAAAAAAAAAAAAA9fHxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABaDGWUjhyVmAAAAAB2YGmhCqC2CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHWgSiT1/KDIAAAAANJ4jkVaxMzsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzEQ8JMwu3AAAAACK7RA8/oy+wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQSDiFGIqIAAAAABFoSbhxyHasAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMnAsW2CeUlcFNwiUF0IXwQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOHk7hC5PIZ4sThmgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkcUGRlQJYIDMBTII0gWwkV9JKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASBIOCDgYPwAiIg8AAAAKSIkot3K1SSYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBjSikYaNCXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1rIYI4dyV6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiwCfTldJdH//+cLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNaJjswYiLxSHA64IuLcwsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALNBpEL2En+ER5LewGNgwqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYqEioRRBV0LF0jOQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Skeleton"] = "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",
			["Ghost"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD3haES6LbiwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1VJLQRHR2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5p46xZr+o+XS7pE8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADRkZMCk1N2RlmZh4AAAAAAAAAAAAAAAAAAAAAIohuHkenlPBrxK7/T6aNkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABDSSYEQ0LqB0dEhwAAAAAAAAAAAAAAAAAAAABjz7g2cMi2/4DUv/9mu6JmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARkYdCEdHXRNMTCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1RUU4aX117AAAAAAAAAAAAAAAAAAAAADCdhRVZrpyJeMGvrXK4nygAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6NHUCPDhtCz5ELQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADWtrEwhiYHcAAAAAAAAAAAAAAAAAAAAAM5l/FILWxHFjs59AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUc8uQY5M3cAMjlCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACmhiYgBpWhEAAAAADEw/FAA/LqkXZlbDRpGB5UuWgMBhspJuWLubSFjDnkUAAAAAAAAAAAAAAAAAAAAAAAAAAAJJR2QMTUP/CT01uggrNB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYV5UAFdTOgdjVUUASj2WHGZWomCyof9nqZv/gb6t/43Ot/0ngWP/Jo1z/02tljgAAAAAAAAAAAAAAAAAAAAAADk57QQ+OeUKSD5KDz8/EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgVS0EbF7bBWpZiwAkJA5owa9wjuHP/pnUyPuRwbX1eKua5BZfSfEdfmracdO+agAAAAAAAAAAAAAAAAhbV3oGRUS6AC83IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAl/bDYAAAAAAAAAADaOfINzwbD+lczC+4GwpPdtpZP/SJJ8xSSXcypSu6WjAAAAAAAAAAAATUguA1RO3xF0bDsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARKOOZHvMuv+Myrz/drKh4ofRuPFVq4yPAAAAADqmkZVNuJ5FAAAAAARXTaEAUEpZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuj303QqeP9k+kjvpsu6XnOpl/2gp3UzEAAAAAIZqFPTSmkaECTEdnB15WigAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAehWu5FGVSsDCQd9wmiHGdDkY4EgAAAAAAAAAAJJWG0gddWdAAV1AjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4XCxxyYVkHRjiQE29YwySHbU0AAAAAAAAAAAAAAAAZjn09B1tTQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASDwVADksoAA8LuADSjr0BE08mxV/agwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARSQn4AOCr/AjUs8gM0LP4CNyj/DGpHZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACHNcuQFbRP8FRjfkCEI2/AhaQ/4Zh2KEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEcFTOBnBW9gJRPv8ATTj+CHpb/RqQbo8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVjTsoEZEy1BFhC8wJZQdkOf1xIDn5ZfTN/ZgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACV1P4AdXRrQCUz31AFA7tAAAAAAPdVWTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSjzkBks8qgRUP+YBTzqzOol1DRNpUJ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARBL6ABPC7NCEg21wdJNcAQTTwuD1M+tAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjkqsAE4KrwJQDGzBj0tzAI8LFwKRDHCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMyOeATAk0gU1KeMDNCbCBTgnWgo9LsIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgxJl0GLiXMCDEp5gUuJMQJMCRqDDUpyQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACigjMworJK4MLia/Ci4lywgrH5QILCLOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJRw+CiQgxgcqIvIFKSGtBSQemQooIdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXFxYJIB2kCCoi3AYrI8kDIx6VBiQf3gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Troll"] = "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",
			["Bear"] = "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",
			["Brenna"] = "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",
			["The Elder"] = "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",
			["Serpent"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI+PXxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADRoROgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQ8PCYLFha4Qx4WRNfEnA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTr6w1BQTVtKi0m4CMgIPUlFRP9KRsUlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwcGtMhkeHbYMCg39KSEe5x0cGOsJFhT6SmBeZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAImTiRqvvKc9GSAcqwABAfcPDw/rHB4Z7BEbF+4WKiPwWIdyYgAAAADEWDoauyIADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOTx5BM3QDRvAQQC9QABAesECgntGxUS6x8dGvZYNi7AyWNHq+hbQ+/tSjJ0AAAAAJZcURYZMzMKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0kGxwGBAXjAgYE8AAEAewFBAXtBgQC60okG/SDNiv6hCsg8JI0JuSfPDDJgEpBbQknJxoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhoaJgYEBeMAAgHwAAYC7AADBO0AAQXtFgYG604XFeRoHRXylx8a/6EdGbYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADyILEROGHBYT4BITDe8EBgTsBAMF7SkSEewkHhjvBQ0M20EmJISSLiOrmy8js1UnICcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADn0LkLtLykYGs7N0VAKCDqYVtL7iYSDe1CKCTrZzcv7RwZFuoBExD8Gjo8fgAAAAAPAAAiNxgSKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChsZ5PaHVssBUNB9crLCvvXjIx6VUtLPISGRjvAxsa6wQYF/YCFhPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsPDewISUc+hgUFe9MJSb+LBobzQIeHeEGIBjwAhsX6wMbGPQSJCQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMzJhQNHh23ChYa4w0UF6wGIBonAyIczwEjG/QCIhvoAxcU/ggbF3kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJjMUAAAAAAAAAAAFHx65CCcd+AcmHugDGRX6BRwXqwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMfGakGIxv6BiUf6AUeG/QHGxjOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABR8bsgYgG/kGJB3pBx8c8AUcGeALLCwXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACFxS7BhcT+AYcF+oCFA/uBhkV6A4rKyMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWFsoECgr1AwgH6gUUEO4HGxXsFygiLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJCQVAxgU2wIRDvEIFRLsBBIP7AgbF/INGhY5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAshIRcDFRHeBh8Z8QklH+wGFBHrBBEO9QQVETwAAAAAT1dGHQAAAACiongkAAAAAAAAAAAAAAAAWWBEJUFKMR8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyEWFwEOC94FGRPxCiIc7AILCeoHFRL7ESUlSwAAAAAFDhFYHx8vEAwZFmQAAAAAAAAAAAYMBikHFRWjEBsgLwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALFhYXCBwZ3gYaFfEGGBPsCh0Z6QocGP4MHxppAAAAAAEKCboQGxreBxcYsFFRORYAAAAABhEXdQsYHf8JIyS9AA4OEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwmJhQFGhjbBx4a8ggcF+wNIBzpCBgU/wISDn86EycNBQwL5wgTEvgQJCPnDRgX0AMYGFIIGhzLDiMm/A8tKf8RLyW9FTgqJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcfHcgFHRb1BRQQ6w0gG+sHHBb7DCUeqRIqI3kDEQ/9CB8e6Bw/O+wMKCT1CCIc/w4mHvUSLCS9FTYoaxQ3KSUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAByMgsggiGvgJIRrqCSQd7QQfF+0UMynuETEp8QIZFe0IIRrrECwk8ggiHeYJJCGaCiMjMwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHJSOJDSYh/wQYEeUHIhvsCSYf7QUZFe0CEg/sBR0Y6A0tJfYFIBm3CBoaHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAccHCQJGRfbBhgS/wUWEfMEFxTrBBkW6QQTEe0IHRb1Cykg+wkzJTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICB0FIBuEDCcf0QkgGPkKHhf+BhgU7QMVEtQEFRJtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFDosShIzJmMGKx8pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Abomination"] = "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",
			["Blob"] = "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",
			["Oozer"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALTZRCnE104NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACq308wsuJINarUXxgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACi/3MLddd1DQAAAACj/20OAAAAAAAAAAAAAAAAAAAAAAAAAACqzFUPsMQ6Qb/cOmClui1VosEyQrnvXCEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJP/eBOH8HAihfNuF6X/eBGs41IlorlFCwAAAAAAAAAA+PilJc/dYkukoC6go5khzKafI7mrtS2Ar9Q/MAAAAAC2tiQOqK8uR6G7Ox4AAAAAnc5IFarpagwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAav+UDIztaR2J9WsaredoFp/fbxAAAAAA7u6sH+fdf0z16HhO2clTbqGOKNqokyvuqpgo4LKnMrepoyxiqqEkWqimJn+lqSePprU0a57GSS2avzxMm+hjF6LniwsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACF83kXpv95F5//fxDP/38Q2PJ/KP//tCnl3G9Z4MZdkO/NYoHNtEi6vqJG5c+1U+jSuFDlwqhB5LWdNOWwlyfgoZIauZSUJ6GHgx3NjZ0okqrKPGqj0UROitNMRo3URhIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAi/9zC43wcSSw9X8aAAAAAMjRWzjZzlZz8dRoc+XIW4zZv1PG3cFg19W0UuTQrFrqzatX7MahUuu5jEXtjVgb6aSAO+K4ojvmmood14mAHNR6fhfQd4kjq2eNJ5R6vEJNr+9fEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKLzfxbU/4YkyclSeNO9TKDsyV+m4sBdx965ZOfamlvuv5JL7qqCN+2SayztkGku7YNeJe1qQBHta00e7rqfTOnUsUbdspwy1YuII9xYZBfXUG0ctXOpMWiHzz8gmeVmFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//zA/BtVGWxq5I0Nu7UNHryWXdyI5Q7rVXO+3Tp3Xug2Uf7XhiGu2QczLtclUi7UU+Ee1WVSHtaWQd7LifS+zGqUvdopg4x15nF+VZcB3WapQliXKzMkd/xVkoRIIzLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//+qJ9C4WpXGqEvZ1bpW4uO+ZeyYXibtp1As7cOGVu1pRxjtc2Ij7YtyMu13XyftXk0a7WFRLO08PRHtbWgm7becSOuciDXidngh2FNoE81qki6Pf79DQC6LRRZVqlUSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALvbdDnWx2dq2bNSqdq1WNbozHHr0KRc7ahoOu20dEntiFgn7YBgM+1hTSLtiXA17XhpLO1sXyftUj0X7TQzEu1ARBjth3oy7KaSPelwcBXiYnIb1Fl5HMVdkieIX7dXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABfv28QkdNtI7OnSp7WsFPX6cFk0fHFdu27hUvtmWE27ZFsOe2nkljtXFId7WpXI+19bjDtZVsh7VJMGu1JQxvtMjUP7UlSIu1PUxftfXQr7XFxH+FteiHiZHsg0VV5G6hqsT1PcOBmGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsrj02h5EtuM6yUc/qx2XdzplW65RfMe2FbjTtdGw57ZCCU+2CbjvtZF8l7U5fGO1VXR7tWlUg7VhYLO1FTBjtUmQj7T9QHe1VWRzsfHsn2WZxG9xfdhvGbI8ml3LCQlBdulApAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjMxMFHO0MlZ9lSamuahFzta2WN2XZC3tfVAm7ZWJUO1LQRLtWEQV7XtzNO1gbCPtUmUa7VtmJe1CTRjtLTwL7UVTFe1PYBrtN00Y7k1bIOd8hSvNaH4it2iQLXqX0U9gXKczY1GfNksAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGnDZBers9S4enMomhoD23sJZE1I5hLvB0TB/tYFUm7U5BF+1YRxTtb28p7VVhGu1NWxftZ2ox7UFLGe1DWR7tUGUj7VdeHe1JVhzsMkQV8VFuJKZkjyuHYZcte3nARlpisE4na9ZdEwAAAAAAAAAAAAAAAAAAAABbyG0OZ+yEG23TXiNmmS2HXokfmoGQLqaVgDXbgmIu7l9NFuxBPhbtVVEf7VVPIe1XWSTtWF8i7WhoKO1YYB/tTV4e7UpgH+1AURjtV2Eh7VBaHOsqPxX2OF8jo1aILYFHeCCdY60/SGvMTy1/7G0cAAAAAAAAAAAAAAAANZ9VGFXNcSQAAAAAn99/EGyxP1VaojBVnsZSTZaOOaNvWx/1Xlse6D1CG+xLUR3tNTwT7URIIO1lZC/teGw27T9KFu0eLgftIzYN7UNSHu1KVSLtREkY6y9EEvM8aSmMT4gzdkJ0II53uUFChdRVKgAAAAAAAAAAAAAAAAAAAAA4nkwyXtl6GwAAAAAAAAAAatVzH2TITTiE9HoZn79fQFxMHthKOBT9UEYc7yMyD+oYJwrrXFMs63RsPeovNRzqKDEX6ycxF+sYJQjrVlkl7ElTIu1AUBj0P1YS5VGGKXQ+izdJW6M/QHzJUyvE/5wNAAAAAAAAAAAAAAAAAAAAAGHmkRVYz2QrT99/EEXnogti13UaY9hYLlOyNUOE1F8wfZFSTTw2GapINR/lKC0W+hYmDvdGQyf3SU0r+BMmEvkdJxf1IycW9xQVBvc6NxjvSVkX6kNgEddmkTlra9ZrJkeTMkeq/5sSLueiC5bwhxEAAAAAAAAAAAAAAAAAAAAAAAAAAFvRaCdY0nkXNcl4E0q9Wh9j2Vk2XcZMP1atTDWc9YkaAAAAADEgKR9FVC2LOk8ktzJBHLY2Rx+yM0cdrEFJILxISB+qTVEhomp6KZKGozeUdKwze8T/dSeF0lMuZL9ROAAAAABI7KMOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGb/zAoot2YZAAAAAH//jxBf338YNoUwKkuWPBEAAAAAAAAAAOj/kBfd/5su//+3K////w0AAAAA2OWFKP//pynM4FNMqMI4baPqUz2H31MxfMlJTFGqQlFBrFofif+cDX//ihgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSdSyJNx1gXZ+d3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIa/RiR9yEs9YeZtFZ7/gx1c0HMLAHVODXDqcBmX/4QbkfKRFQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzjjMZNJw0LFjCUy5i12INAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGrpfwx114kNkOh5F67/hhOQ+Gcli/NoLJ//nxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAo/9/Dpr1bRxaw1oibch/DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Draugr"] = "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",
			["Draugr Elite"] = "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",
			["Leech"] = "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",
			["Surtling"] = "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",
			["Wraith"] = "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",
			["Kvastur"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLQzdAJiMdTwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUkkzOxARDf8DBwmMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmZdw8REg3cAAAD4AAAGRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTk4NEBIOxgIFBf0HBwdEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODgvGw0NDL0BAwOaBAgEPgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8nJyALDQzKAgICWgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADhILxgADA1UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcJBKMCBAJ5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBwdqAQMDogAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkAHAIDA8MAAAARAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAabAAICXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBAMPwUHBa0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBwWrAAAANgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgLVgMFBpMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAoEBQWvAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQ0LbgQGBncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgYlMzMzFBISEg4AAAAAAAAAADEpKR8WGBOzAAAADgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASEhIOBw8PIAcHBYUQEhJvAgcFrQAAAG8XFxErFBYSoggECDkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFDwozAAIEdQQEBJoGCgjIDhIQvAIEA+EFBwWGETMiDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFVERA81Jx+ADw0L3AgKB9IRFQ3qEREJ1SwsH5tBPSp4WlI0IgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdUxAP0AqI/oJDAvvDBUR8RogFN0jJRi9OTgnrTk1Jq1PRjJ0lnhaEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgIHQQGBm4MDQu5AgME6gACCOoECwvsDRYR7xIXEe8pKyCHVks3c39lSFiXbEsvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAFBTMFBAevAwcI1wAHBeULFBHYBAsK5AIHBu0AAwXpAQMGpAAAABIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAg9DBARugQGB+sFCwvqCBQR5RQeGvANGRTjCRMP6SEkHKkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANBQoKLwkND4YFCAr0BAoP6woVFuQUHxzyDRkV1BMfHM0aIx/gGyEYpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCywGDA6hBAoK0wQMDKMIExm3FSAg3R4nItAIFBPVEh4c6SMvL9cJGBieMzMzCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAkJNAEICNMECgrSCBMQnxAgHp01OzixPEE5pAcTEc8qNjPOKjg3uSIuLJQUIh9JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAgfAg4MehIZGYsYJCGmESEe6iMuK+AdKCPpESAc3TlIQcIdKyW3JCspkhghHlMADg4jAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEREPAAAAABwuLIUcKijOEB8cxBwpJMMZKiXTM0E6rxUkH7QbKCaDLEIsFwAXFyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5iYg0PHh4hHiokKhswKSUZJhkUDh0dIwcWHiIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Bonemass"] = "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",
			["Wolf"] = "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",
			["Drake"] = "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",
			["Fenring"] = "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",
			["Stone Golem"] = "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",
			["Bat"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC45LhYtOC0tAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcKhwSGCUakCYuJiEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABodF7YWGRJRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeGhXAKhoWogAAAAAAAAAAAAAAAAAAAAAAAAAAIS4nTRkoHjIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIRkRrTkaFOpaHh4RAAAAAAAAAAAAAAAAAAAAAAAAAAASJRq4DyAXlQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8UD6FUIx//Xx8WUAAAAAAAAAAAAAAAAAAAAAAAAAAAHScnGhAgGugQIBniFyIXFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPEg9xUiIb/3ciHqUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUIxxkEiEc+hIhHPoTIx9zAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADRINNy8ZGfJyIyDleBwOJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIfGmIQHhn8EyAb8BQgG9MSEhIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiEQ8SFQ/LUh0c/3oiIm4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAbLxIeG/APHhnpEiEc/hQjHmUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEx0Uky4ZFf9eHhm/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEyId0g0eGfIOIBjzEiMbzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMjFlAlGRH3UhsY9GchGUUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaKCKjEiId+w0gFucOHxf7DyAadQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPJx8gHB4U30wdFvxqHBi6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABclIG0UJR/9ESMa6Q4gFuwPIBj4ESIZWgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUWFrQ5FRP3cB0b92wcGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACRcSNg8gGvERIhrqDyAX7BAgGe4QIRrzDh8YSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGxd3IhQT/HAbHvCAHRvSMwAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGQoNGhQmDx0Y4w0cF/cRHxrpEB4a6xIiG/AQIBvqCxwXLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhQPcRAREO5XGBbpjCAf/oYaFWEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMDDwIDgtWDRsW1xEfGvgOHBbpEB8a6BIkHv8PIx1yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgR/Iw0J+I8hHfmeHhmfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwchCxkVyRAfGvkRHxrlEyId/BAkHZsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEDAYFWGBP/nSMfy68fHxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALFwsWDB0YxQ4fGfoQIRvuDiEb1w8fHxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKA4LxH0eGfm7LCM5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIRYXCRwWxQkdFvgQIhv5EyQejQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAC9IFRD6kyUdogAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcKhwSCBsVugocFvcNHxnyDyMbQQAAAAAAAAAAAAAAAAAAAAAAAAAAIwwGenIgGvnMMzMoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPHw8QBxsVzAkaFfsJGxTUCRwSGwAAAAAAAAAAAAAAAAAAAABLEQ/ZkCQhogAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGGxFKChUQ9AgXEfcGGhXCABMTDQAAAAAAAAAAFQYEdWodF/+2MClKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3IBuuHhsZ9AIWFvgeEQq6vE45WAUVFS8lFxTwaCQh16oqFQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgICH4sHxv/DxES5YUvJvzETTziDRAIyxQUEv8nDQuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANBcRC/IYEgPplkUz7WwtJfALDQnzAwgH6wAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQzEXrm5ZNf8pGBDyBgEC5xIXFPkbHx6gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACFbkIuYk4olggFA48BAQPwFBkV+Sw3MIoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDB9UABAT/BxUMyQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgICYgADAKUBDQWGBxYWIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAoZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Ulv"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZmZmCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSw/N7JeZlmabW1tHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAuIzUx8UVSScM3RjtFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC8/RyAwRD5aDSIlbkhXVyM4S0KDTGFZPAAAAAAAAAAAAAAAAAseHoY0RUP3RFRL6TxPSEMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAX2pfGAAAAAAHFx4hGjAwXyQ3NKklOjapJzs4pypAO8o6TkNyXGZhNwAAAAAsPjE5R1ZP0U5aUfM+S0LeRlxVJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEtaSxEAAAAAAAAAAAAAAABqbGVxPUZBOgAODJAQIiC6JDo2yiY8OfElOzfmMkU91jxNRrlDUUmASldKYGFsXuN8hHXvW2FV/jxKQaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUlxPU25uaS4AAAAAAAAAAEtWUotATku6Hi0r2REfHPQZMSrwEykh7CQ7MuwnNzDtGyol6R8vKfVGVUn5X2th7UVQRv89SEChS1paEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8PDwiZ2lgkSQrJCMGDAxROEVCi0pbWP8bLCnsHSsp7CY7NOwiNi/tN0xE7S88Ne0FFRLuPk5J6kRQR+s8SkHmQlBHqD9KPxgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABHUUqoHScfygAKBtQeMCrUJzgz8BEgHesJFBLtNUVD7Sk5Nu0uPjrtKzcz7Ss8Oe1AT0ztN0E78ERQSJ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAeHGwVIhz/GScc7A0gGPIMIBzsFyYj7RYkIu01RELtKTY17SMxLu0jMi3tFCQi7RknJe09SEHpOkc9ukpYTksAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMzMwoRGho6Ag8NwC01I/FtbU3rNEI37BQuJu0hNjHtGSkm7SMwLu0XJCLtKzs37Sg5Ne0nNzbtFCAg6yUvKvI9Tj+tY2pebAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIRYXEyAgXQUODusNFhD3dnBS7aicd/FIUUTtBh0W7QQSEO0DCwrtAwgI7QcREO0mNjPtGi0p7RAgHu0THBzsBAwL8RkmIt9thXkVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRGh0CDg+0ER0c80ZVTOlTW0jtFx0T7R0uK+0PJB7tEiIg7QcSEO0AAgTtAgYJ7QQQEO0NHx7tCBcW7QADBO0CDxDtLz066jxNRrRLV05VAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChkbjQELDfoSHh3qOkxH7Sw3MO0CBwXtBRIP7QcUEe0ECgrtAAQF7QIDBu0AAQXtAAcI7QoXGe0kNDTtFB4d7QAKCO0mOzbsMUI5+VllV5J8iW8nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFRXMAAgI7gAKB+wFDAvsAAYF6x8sK+oRGhvrAAMF6wMFBuoDBQfsAQMF7QAEBO0ABAPtBA8R7REhIO1SXVXtUlhS7S47OuwxQj3tMEE461BeUFkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAePC0RCBcYjwIMD/ABCgztAQwO7AYPDO48SEH3Ljc1/AAAA/MDBQfzBQcI+wIEBfABAwXpAAUE7QQMDO8RICHtAhMS7RUlHu1EUEjtSFVR7ig5OOgmNjPiZnpwGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcVF68GDhL5AwoQ6wMRFesCDxTtDRwe8EFPSaQKDQpeAAICsAIEBs0DBAejAQME4wEDBfwAAwTsDBYV5QwaHO4MGRzpDR4e7RMnIu0wQjvnLTs78UpSUdytopYWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDRJfAg0QrwMJEcMCCw/xAxIU8wEMEtkABg0nAAAAAAAAAAAABgAlAAQEbgAAAAAJCQkcAwcIjgAAAcIQGxnMICos9QADCfwLFRnsFCgq+CExMWwpNzSmZnBq7LmtrRYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFCYABQpeAgYL4gIMD/MFERX2AwkNTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANEBAP0FOTOkyPT26BAgOeQIJDO0OGBn5GisrtBkrKJ8pPjnrSFVVFQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADw8PEAMIDscABwv3AA0Q5wMSG1QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBm8OFxnzMD09/yEuLYgABAQ5CRUV7AsXF/AZKinGYnFn0VtpXORqf3QYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVFR8YAwkOwQINEP0IHByrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMGTQAFBVgAAABGAg8PdxIhIO8WJSTyGyws8wgTEvYyQTj/S1pO4zU/NRgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCw2BBxga/wcdHsYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABDgYKCqpGisr9hssK+YDCwuXAAABiAABAZoADAg/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALgDEhf7CRkiqgAICB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9PPxBia2saCh8XeQ0jH/MWJST6EiEfegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHTMsRS9EPqdJU02uOD066x0mJ/MdKytGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhPDhEPUxG1TxPRt5RY1XrMEI79QgZGdYWLCEXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABswLpM6Tkb9LEM6+lthWPWrq579aG5j4lVcVSEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM0ZGbCE4NvckODD+HTUr+i1EPfctQT7EEiQkYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMIiCjHjQv/yY4M844Qz3aZ29m9lFaVKAiLi4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADpMSEYuPjv/EyQg4gofGKkOHhqvAAsGcAsjH0EfNzcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADx4lIhYqKpYuQkB/JTIyZlNbWLIwPDxEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITczRRkrKGQGFBQmFxcuCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtNDwiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Cultist"] = "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",
			["Geirrhafa"] = "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",
			["Moder"] = "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",
			["Deathsquito"] = "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",
			["Fuling"] = "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",
			["Fuling Berserker"] = "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",
			["Fuling Shaman"] = "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",
			["Growth"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAAAADwAAADEAAAAbAAAAAAAAAAwAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAjAAAAGgAAACcAAAARAAAAEQAAACYAAAAuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAABAAAABRAAAARQAAABsAAAAAAAAAIAAAAHsAAABhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARAAAAJgAAAEsAAACFAAAAUwAAACEAAABMAAAAYwAAACsAAAAWAAAAGQAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEgAAAEkAAAA2AAAAiwAAAG8AAAAtAAAAUgAAAHUAAABpAAAARwAAAEsAAABiAAAANQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAewAAAJgAAACdAAAAhwAAAFUAAABfAAAAXQAAAHoAAACHAAAAOwAAAFIAAABJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEAAACvAAAAwwAAAIsAAAB3AAAApgAAAHMAAABuAAAAvQAAAJcAAACGAAAATAAAADIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAOQAAAJUAAADKAAAAlgICAmwAAACQAQEBxQAAAM0AAADVAAAAvQAAAJQAAACfAAAAQAAAAA0AAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAFoAAAAWAAAAqgAAAMsBAQGzAgIC6AMDA+YEBATuBQYG8AYGBvUFBwXWAQEBlQAAAMUAAABLAAAAJQAAAD8AAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsAAAB0AAAAYwAAAFMAAQCsAgMC0gEDAu8ICgnwCQsK7wQFBe0GCAjsBQYG6wUIB/MEBgXdAAEBuQABAKcAAABeAAAAXAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbAAAAVQAAALEAAADDAAAAXQABAYgCBAP0AgQD7AMEBOwGBwftBAYF7QACAu0AAQDtAAAA7AMFBO0DBQTsAQIBygAAAJwAAACqAAAAkAAAABoAAAAfAAAAFQAAACEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEkAAACVAAAAoAAAALcAAACJAQUDxQACAfYAAgHrAAAA7QABAO0BAwPtAAEB7QIEA+0EBQXtAQIC7AIEA+4CBAPtAAEAwQAAAIwAAACuAAAALwAAADgAAAA9AAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAXQAAANUAAADXAAAA4wECAtYDBQToAAIB7gACAe0AAgHtAAIB7QABAe0BAgHtDA0N7RcZGO0AAADtAQMC7AMFBO8CBAK/AAAAeAAAAEoAAABEAAAAVAAAAEMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATQAAAGkAAABWAAAAyQAAAO8AAADgAgMC5QIFA+8AAgHtAAIB7QACAe0AAgHtAAEA7QUHBu0EBQXtAQIC7QACAe0AAQHtAQIC7QMEBOUAAAC9AAAAVQAAAGgAAACWAAAALQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhAAAAagAAAG4AAADNAAAA3wEBAeMCAwPtAgQD7QACAe0AAgHtAAIB7QACAe0AAgHtBAYF7QIEA+0AAgDtAAIB7QACAe0AAgHsAQEB7wEBAdwAAADYAAAAoAAAAIEAAAAjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAACoAAABiAAAAkQAAAMMAAADrAQEB6wQFBO0BAwLtAAIB7QACAe0AAgHtAAIB7QACAe0AAQDtAAIB7QACAe0AAgHtAAIB7QACAe0BAQHuAQEBzAAAANIAAAB9AAAAeQAAACoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnAAAANwAAAHsAAAC+AAAAywABAOYAAwLsAgUE7gACAe0AAgHtAAIB7QACAe0AAgHtAAIB7QACAe0AAgHtAAIB7QACAe0AAgHtAAIB7QEBAe0BAQHuAAAA3gAAAGwAAAA0AAAAGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMAAABmAAAAtQAAALgAAACtAAEA6AAEAucABAPuAAIB7QACAe0AAgHtAAIB7QACAe0AAgHtAAIB7QACAe0AAgHtAAIB7QACAe0AAgHtAQEB7QEBAekAAADVAAAAlgAAACEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAagAAAIcAAAC2AAAAggAAADkAAQC2AgcG0wADAvEAAgHsAAIB7QACAe0AAgHtAAIB7QACAe0AAgHtAAIB7QACAe0AAgHtAAIB7QACAewAAQHxBAME3QAAAF8AAAB4AAAAJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMAAAB4AAAAYQAAADAAAAAZAAAAHgAAACwCCgerAQMC9gACAekAAgHtAAIB7QACAu0AAgLtAAIC7QACAe0AAgHtAAIB7QACAe0AAgHtAAIB6wECAfMGBgbAAAAAjAAAAHEAAAA0AAAAKAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAGwAAAEcAAABEAAAAAAAAAAAAAAAZAAAAAAQUD3EBBgT/AAIA7QADAesAAwLsAgED7QIBA+0CAQPtAAIB7AACAewAAgHsAAEB6wACAesAAwHrAgQC+gMDA5YAAABIAAAAVAAAAEQAAABZAAAAdwAAAA8AAAAAAAAAAAAAAAAAAAATAAAAMwAAACwAAAAYAAAAIgAAABEAAAAAEiQkDgMLB4ICBwXkAAIB8wMBAu8CAAPuAgAD7QEAAu0AAgHvAAIB8AACAfIAAgH0AgUD9QACAe4BAQHDAwMDngAAAE0AAAAjAAAAXQAAAE8AAAB7AAAANwAAAAAAAAAAAAAAAAAAAAAAAAAXAAAADwAAAAwAAAAUAAAAAAAAAAAAAAAAAAAAAAMLC0QBAgHAAwQE4gIGB+gDBwjuAwYG7QABAeYAAgHgAAEA1wMJB8ECBwSuAQAA2AEAAIYBAQGLAAAAYwAAAEkAAAArAAAAEAAAAB0AAAAtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBAAAAQgAAAIIAAgJqAgUFWAIGBnoCCAhZAAAATQAAAF8AAAA9AAEAgAAAAJoAAACQAAAAsgAAAI8AAABZAAAATAAAAFAAAAAwAAAAGAAAADEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEYAAABTAAAAPgAAADIAAAAbAAAAEAAAADgAAAAeAAAALgAAAB8AAABgAAAAmAAAAD4AAACgAAAAkAAAAEEAAAArAAAAQwAAAE0AAABcAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGgAAAB8AAAARAAAANAAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAJgAAAGkAAABTAAAALQAAADEAAAB1AAAAkgAAAGoAAAAnAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQAAADIAAAA2AAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAALAAAAAAAAAAAAAAAgAAAAJQAAAIEAAAByAAAARgAAABUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAA1AAAAIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Lox"] = "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",
			["Vile"] = "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",
			["Zil"] = "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",
			["Thunder"] = "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",
			["Yagluth"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6M2YZ9C+UMPMLeGz2IIM+83nSF+eL0AsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEtCQhvUqsYSgk1qK4gOPnu4E1yt5A1y6fwGdMj2BnOY8SSNOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHSAgTlI1O3OAQk9jmDVKwIAQMsS3D2DD/BOG9v8Dfej7BXSZAAAAAAAAAAD/eMMR/4jdDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA67D/DQAAAAArHiFkQTAkvH9bSsajf3PudEA43rkkWs38Gojz/BaG//cTe/fsAGNF9ABvR/wTeVr2H4BZ/2O8FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADpqtQM85bcFsiIvxzIbJpC/6z/H0ozPoJQRTT3n4xz8U1ALO1hSzPujj1O2ucmfPD3L4rw+UWa8fc7pu35J5Lo9QVxxPACbs31C3lt/1q0EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3WuuJuYzfmf1OItNz1iaK8NgimfKXYabNxIZ3FBKPfCmnIfqWkgy7VtHNu08IR/pq05y2v9ntOz9ZLv3/4bc//5wyf//R6r/9jSZ/PYcifDvD4CFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANaZ1hnqRpBM8zR7a/UqeW30LXtl8C17VcseZGN8M0i9clNR9nxuYut8UlXvc1pQ71hBOuTXWJPr/Vm3//JeuP/2fMz9+ILQ/f+N2v3/jdz9/3LK//kulvnuCXBPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACvr/8Q4I7gGe5Hi0v4P4VQ+DF2dvoqc37wKHFs3ShqeL1riLeIY2r3b19T6pJoa/CDZ2Dsm1Bp5f5dqf//ZrP++W7B/vhvxf76fs/+/Zzj/vyZ3/7/jtz7/2rF//oiiNj/AGoMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+//xDhe70j8FueNfhIjUrxLW5v9Sdrbe5AfIveTH23ejVG61FBN+5NRDDtinpi7W9VSuuzQGnh/FyX/Pham/33gcv++4/c/P+M2P7/meH++pne/v2L1/78Zbn9/y2T//gPeVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2qraFd10sS7nXKI39UaNNv9elFboZoqn3W196c9KcPi+NmndaTtA7Yt1b+xlVT/tUDQp76tVauTTJ2fq+0mZ//l7xP78n9/9/6fc/v+e2///mOL//4TQ/f5iuP/8HIXs8hF5OwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXnOEa6mayMt1ZlDzVcIuNsk9j5KU8VfusOVHUxhpVkO4gd5bSbJb1uoeY8a1yde3VgJH0/N/p/d1kjeX1Q4/4+k2i//dXp//6b67+8nOk9/WXwvf8h8r8/VSv//UXfNHuIogeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqtTpDNptvCrvTqYx1XF5m75qav2VK0bCqCJSfOA0dGvgL3ON2wtma5g9Z8+acG70plpk7/bO4vz//P/+24qZ8OZIgO//S5X7+EGT+/o/nP7UInHviyk95b1+gOnhX4z45Bp2iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQ5/8L54fPIO5mwx7UeHe00IJo7OdFb2D/MoRw+DJ0dOIzcWzCHmF+fDJVunJDT/fwtcn4/eT4/v/t+v/UlZv1uTJW6u4ygO3lHXPv/zqW/P0tjfnhLXjxj0RG5qiBWfLLZW2a7iKqDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADhg8Qj91K7IsldbY7VgWz86FJye/0ecob4JW+V/x12Z9McanWbMV2fiztj6vaw1P3+2PL//dXq/KZcbO+BHjHsvRxe7NcYa+v/MYDm/SmB6+whfd+3XVnixKdk9MdaZc7qFHllAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANyL0Bb6YrQ+zlh2f8Z1Y/rgXHKP/xlwevoVb6X3EHOJ/xt8Svk9l2CtHGTYtR5f8upuoPLmW4juty5Y7Lc+YO3DHmLq7Cl72/oldLr/KHjM2kBzw6l+T+iijEvyqzdTuPkie5PvQ4cxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAz7+/EPqT1zTSQXlWs1RS7NlUZbz6Fm5//xRzkvcZeWX/FHhX/RF1lvs/m9LTI3Dw5CJs6/k1f+7uNoDr2y117vc3iOD8MIPR/Cd3r/coboqnYFrGpo9P+aBlQtDdQHWS4zd2l+s+f2oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4uKoS8LTwEco0gTXEYmza3Wdy2+8cZ2PzEm5s8ymMQ/8vmzb9CXWC/S2NxfxUqO/4Sp30/EiU8vtGlfX3P5Px/S+K4/8rhN7/KoDQ0jNelHJPLuSOb0HwyVhhi/o4dXHoSIKJ51COVtiy5RQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA06GoaqZ6ge2kXm3mz2CCpvd7p2PheKUR/1vBGf0JgIH9FH7P/0ah6/9fs/b/ZbX3/Vmt+fxDne3yJ4Pn5iF35PQ4hd+vT1ncblMz+IU4PKj8Tohl7z92cOxUjV7YiLY8qtT/DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFuJxQuX+KYMFdi1+3R3wr/6XAJQAAAAD/K54d+wN2pPwOetT/LJDp/z2Y7f1Dmuv6NpHk+SyI5elEheTkfZ7mnjxV6ZJaUfOOUkrl2zdqifY+fXLqTohL5FaSRNZ4qjkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/tMMRAAAAAAAAAAAAAAAAAAAAAP8wkRX2CW6b/Ah10/0chN3/MZHu/zWN8/0xifD7KoPr80iD5uZyluOeEk7TlyFMz7ouWqP9PHSI8TVslOpFgGPdWplEzI7BGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPYTd1z7BXHB/xaB4Psti/b/LIXx/yqD7vwrg+32OoTn9TKF4Psff9DzBmqq9iVzj/U2doPyN3CK40J7Z9lnoi8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPcLcoP9DXvh/yCC7voZeNj/IX/i/CSB4vsthuT/KIbj/QpyxvsAaaD1H3SI/DiBaPQ4dXXgToVU1Ii7HgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/y+XG/sHcan9DHHK/QpxxP8UeNP8GXvQ/Bh92v8Pd9H6AGq4+w1vk/wzgmTtNX1o8D6CZuNgnkLJn9QYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+x6BQ/kIb5f6BGuj/w10uv8Sd8r8Bm/N/wBqsfgFbpL3InWH9Dh6ZOc5f1jmSJRK44nOJaq/6QwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+iyPOfwkhFX4E3h0+QxxkvoCbKv7B3GF+yWJSvI9h0/tPIJY50SLS+BfpDvS0v8RAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/2i5FvBNqiT/S6wl9R6BbO4wly/0hOAZ8ZPkE+V/ux7hZrA01YPFHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADpar8MAAAAAAAAAAAAAAAAAAAAAMa48BIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Hare"] = "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",
			["Seeker"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEwAADQAAABEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVz8VXVEsEbl5OxjYl00m3ZVLHradUx59kVAgRnQ/HxgAAAAAAAAAAAAAAAAAAAAAJzonGhEiEQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBQAGVcrCsmZTyD9s08l99loNvL6gkDy8Hg0+uFqJfrhbSr/2nc05c9zN0AAAAAAAAAAAAAAAAAAAAAAChQKGRYeDyIAAAAAAAAAAAAAAAAAAAALgEYVaYxVMLJ9SynFimNBqz4vF0EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKw+kt0wr/+hoN+fTWCXq7W007PVtKezvayTn62gj9vBwJ676fTA1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALS0PETMnFi1yRiMdxVwvYcVlKdHagjz+65dk+dFoPvPdeU7/m2ZEzDNmTAoAAAAAAAAAAAAAAAAAAAAAQTMWWZNDJfr2ckLp+XhC7tBVKO3KUSbt2VYg6ORjJfzXXx2zAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFOH3jdcTj/9HIy8+lnK+nvdT/q93M27P9+SOe0eVr8NDQkTQAAAAAAAAAAAAAAAAAAAABbMxa4tE8n+fNvPuviYzLu2lYt7fFjL+vxZyj45GQnzeRrNRMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ9IFYPUYCT66W8y6t9kLO3rbTbu32M37JJLK/U7LhE8LDUTWyw1HrZATTNPChUAGH03HuPJUSnvx1gi7dBbJu31bzrs9W4v8fx2Md3vcyYhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxGITDd5qKNHjf0byvWE07L1RK+27TCXuplYv6ko9HMJDRCL1NzEf+jcyKOpXKhjSxlIv8s5EJOznZTTt3Wcp7OhyNub5dDP892srZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8W81sOR0Rf/YZzzpymAx7Wc6GO1KMxDtTUEl9VRGMOwtJRXqIBIL7oU1IvPNUins1VYq7uNkN+vYajbuzF8r+txhLfPiXCokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZn9mCjxLLRE2NiQOAAAAAAAAAACuTiCbqE0n1sVdOOq5YDHshGxA7YV8Ue0vMBrrJyMS7R0gEO0pGwzsijke67hPJ+7PWzHqwFcw9qdMJuijRx21pUobnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAENDKBM/Py0cPzYbHDA8GBV3VzNaYzkY+kkmC+1gTjjqi4Vq7Q0UBu0DBQDtAgQB7SgSDe2YPSftt0sn64w6G/Z8NxrNcC0KMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALSKXxhONB9hQCoV6DkqGPolIAvvBAkA7BMXCu0FCAfrFQYI64hAJ+y0UjDxhDkk2V4vHBsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABeORygLSQNvxIMCNwBBAbvBgkH7A8VDPQEBgT2RB0P6YM+KfhQKCG9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNVUD9pKCMY9gQGBu4DBgX2AQkDpgUPC4FLPSr7OB4T6wkHB+4FCwstAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJTP6UhHBK+AAAA0QIDB/8EDBA/AAAAAB0hE84UGRLzAAQF8QMPD0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOyYWpzMdHSMDCg1JAgkO5gcPDyEAAAAABRoUiQ0YFf4CCAjXCwsLFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlHROAAAAACxIkJA4EDgixAAAACwAAAAAGEg1wAAkI/wIJB+AADg4SAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUtI2QVAAAMAAAAADsxJIUUFBQZAAAAACAaDn8KDQisAAgIfgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQsLLQsXFxYAAAAAOjoxGgAAAAAAAAAAQTciSjglEhsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Seeker Soldier"] = "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",
			["Seeker Brood"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ9qHxjTqF87AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOC5ZmuNZi5uAAAAAHljWBdpUjwiAAAAAIFgLWq3jESy26pV3u/KcPj/55BhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOnGaiTy5KC3//Sj/7OMT/9uWTTLTj0l0UczIzLgvlp2z6RN/82dUPiFZCbw6sly7//ukPP144um+eOEXvbaeT/32HBk7tZtPwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPHaljj75K2m/PC95P/6wP/eyYfu3Lhp6t64cfiHbTXzpoQ3xeK7V/XWrEvrv5VE6nRYJOzFnFLs7sxy7P3olP375o79/eaJ9/XXdPrv1nAyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3cyLav//3f///+T44cuI72FFFuvJp2jt47Bf68qUTevHlUL12a5Q69O4XevAok/tmGwu7a16N+3XrFns+9uC6vveg+b34X/68Nx8nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD77KWj9vC5+dzMnu/uxnXui2Ys7Uk7He3OsG/t2rFs7eK3Z+vauWPv1rZg9b6VR+x8VR3t2Llw7efVku/13Y7v+NV06/PUdPTo1no4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtY5PZPjVgP+6mVHrgWE27OC+be13Wi3sIhgI7EAxEO1tWDbshXFQ8DsuFt/Po2fA4LFa8+jLbu3/8aTw//S69fvnpuz82Yj7+dSCtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5MmhE/rkqzq4nVXZ1rRf8uW8dOzQr23taFEg7FI9JO45LRbyaEkn7FAzFeoUBgDwPy0a3rubZn3wymrr/dx67Pzrp/H/9rfv//O19/nYk/HrxHo0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADo0pAX18h9M8evb0Ddv45Et5xhyaiSUvyWejTqq4FH7XlfL+xJNhnvbFY16j02G9tTOyDxi2U/+HhVNOpPMhr5hHFF7PjXb/z10mv3/euO7v3wpf3u357yyaZkUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXv38g1rp/ONS8fzbKuHIdr49PEAAAAABVQBdrcWk++UE4EeuUe03tYk0t6UMuEPxIOQ2GFyIXFjMkGUZuVjjIb1M3+FM5IIaPfVNJ6M5wiOXGcsjpyX3u3cF3rZ58RC0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2bt/Isqvch0AAAAAAAAAAAAAAAAAAAAA5cx/CuDHhI5iVir1PTYd50pCLO05LxTuj3A38MKKUL2bXkIuAAAAAGtEJy1wWDv4VUg0PwAAAAAAAAAAAAAAAH9QNSYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMylZhTSuXdcq4pVyZ57Stt6Yzj5dVgu7IltMtOti0vrk187/4lONVsAAAAAAAAAAF5BMtlOOC9RAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOm/fwzKp3Id4saNP76mb5PTuoaUrZFVnKCBSbenhEjvz7Fv3bOSXd9BHg58tHhLEQAAAAAAAAAAY0U5fWpKPU8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADr14kN2bx6GwAAAADmyqBc5tClftW7iVcAAAAA///CFZ2ITDzWq3GopnxNqAAAAAAAAAAAAAAAAAAAAAAAAAAAd1VEDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/+GlEevJmDTXsIkNAAAAAAAAAADexIknAAAAAKN4RplfPSB9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD316cg5cyZCgAAAAAAAAAAAAAAANq8fyoAAAAAgmc4eVhCIVwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD01qMZ4riNEgAAAABrUzxMaE45WAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIW1EcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Tick"] = "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",
			["Gjall"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/7Mg4/+G8Tf/dtlv/3LR3/966hv/Yr1f/2a0v/+S7EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/9+3Of3Ys4P/27az/9Oqt/nLncXiq4K+nHRYf1hHOUvuwJMt7MOXp+e+k/ntwpb62a6G/sqfev7Honr+zp51/M+befDWnnng3KF7q//nuQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8MilbPLNp8/nwJnyvZt2/qeNavmpjGf4o4Bg9nJXQPdNQDH+aVY+95p4Uuu0k2/617WR7fTQp+vwy6Xp2LaS6cGae+mkfWDqdFdC7XRSPu6ba1H/nnBdnwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/9+/IPvcto3207H8+9ey9/bQqOvasY/plHRc6kE/LuoqOCvrHi4e6zE0I+mHdFfrw6mI7/TYte3/4r3v/9u37v/Wse38zqTt+cCe7fGzle2vhGrtODAq7DUyKOhVRz7/Ii8vUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/37zB/+jE//3gvez93bnt/9qx7v3Tre3xvJnti2pW7SErIu1JVTvttJ+A7ffVue//58Lw/d267/rZse3/0azt+MWi7em3ku3hqoft25l97bWAae1HQT3tChke6h0iJfYPICvDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/9y6Yf/fvf//3bzr/OC88PzeuPD/2rLu/9qu7eu1ku16Z1XtRE097d7Eo+3/6cHv/eG88PvauO/91rXt98+o7fW/nO3ssJDt4KWF7dWWeu3Bg2vtkGVc7S8xNe0IFBvsAgoO8wMVINQVP1UMAAAAAAAAAAAAAAAAAAAAAAAAAAD72rfD/d24+P/due3/4sLw/+fI8P/euu21oHvtcmpM7TZOPe0aQC3tw7qX7f/rx+775sXv/de07frJp+3uuZTt4KWF7daZfe3CiG3tq3Rf7YpgWO1KPEDtCBci7QcTGuoACQz5BxUfswAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPrVsMz51q30/Nmw7P/dwO/74sjuop537VZqSO2BgVvtbnZT7TRcQ+1PZEvt6ti17fHPqu3svZjt6K6P7d2ce+3Ci3DtqHhl7ZBiU+1vU0vtOjU87RQbJ+0NGiPtBBAU6QAMD/sMHSaRAAAAAAAAAAAAAAAAAAAAAAAAAACwnIkN9smm0/jMpvP3zKfr+cuj7c6ng+1gaUTtmpRr7bmede2Ti2ftQFFE7RovIe2qlG/t3qeA7dOceu3HinPttHpn7Z1sWu2IXE7thl1T7VVHSO0KGCXtAxUf7QoYHe0ABgXmAxIY/wsoNmwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADjt5e388Wj9/TBnOvotIvtiWtL7UNONe14a0rtjnZZ7VlTPu0kMCXtCBgU7XVfRO2+hmDtuYRl7bB5Yu2dZ1rti11P7XtSTO1cSETtHyMo7QUTIO0IGSTtAg4S6QEIDfcHHCTZGDlKHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKiBZo7qvJv+9MCa6N+rhO1yYELtTE0x7XRZNe2BYEDtW0Mu7T42JO0XJBntS0cy7auAXe20g2LtpnRc7Z1qW+2CWVXtW0dI7RUfI+0GFh/tBxgg7QgXIOoCDhT3CBge3RAsNy4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyp14ROa2lvb/yaTqxZBs7GJfO+2ReFHtwIpc7cqRYO2udU/tiWBC7UVKNe0bJhjtiWpQ7aV0Vu2ib1nttoN17XJYV+0YISbtARIf7QYZJeoHFiDmBBEa+AkYH7sUKCgZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnHtofLCHa/+acVTpeGZC7cGEVe3dmm3t3qF07atzSe2BTzPtW0077QUPCO05LSPtfVlE7YJTR+1nRz7tHhoY7QcVH+wJFyPvDBYa/A0WHf8GFiLmDx8vIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZkUvh007MfxyUTrqyIFS7diWaO3ZlWXtnGE77WE/Ke0kHhTtAAcC7QkLCO00KB7tNiMe7SUZGe0MFhzsDBsm8AwWHOAYGBiQFx0jgw0hLiYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxUVmF5AMPzGg1bqs3BH7bZsR+2gYD7tOikd7QwMCe0FBwXtAwQE7RMPC+0iHxrtBxIP7QYRFOsHDhT0BA0P0QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAc088lKFkQ/p6QSDqjlUw7mA8KO0vHxjsFQ8Q7QAAAOwAAgHtBQQH7QIEAexBIxbsIBQR7wEKDOIRFhfXAAAAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABeTjNBWUQr+kgiDe+MUDTyPCkc7gYDBPAAAQHtIg4M8igTE+0EAgbsMhIM83AjG+4mFxfuAQsNyhMYGMgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXAAsZJx/BEAwL3CcaGNofHhTpTxYN4HgoG+6zPSvbkjsj8A0SCe9FGxLiii4fch8TEt0FBQerExgQqgAAAA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAjHa4JGRWEDB8TkhAVDtjNNx4zUCEY05U0Ix15MRxYFRMQ/QQCAnYAAAAAHg8L2gsNDYgrLSauAAAAEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAESQdkgINCHVhb1B+IiUa25MnHRo6KyTMAAAADXdVVQ8QDA7yAgcHYwAAAAAqGxnFERETgyciHqkAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPIxZlAAoCdHJrUW0kIxndoFUlG1c2J8MSAAAOi1xFCwcOCNkACQA2AAAAACciIrMRExOOKR0bmwAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACo8LkgLGBOFW1tAXyIiGeKMMz8UTi0lrAAAAAtbW0gOCxYR1wAGACkAAAAAJCIioQsRD5UmGhiGDAwMFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOUw+NSMvKJAoMSJSHSQa2wAAAABYNiKWAAAAADA3KSUKEw7ZAAAAHAAAAAAVGReEBgwLoCIVE3YWCwsXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxRjgkGScglB8jG0EVHhXKAAAAAIJRPpMAAAAAHC4iLAsTEcMAAAAAAAAAAAwUEmMGCQahOCMhZAAPDxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGZmTAoYJB2THx8WOR0fFaQAAAAAckQyg2YZGQolNSowGBYVpwAAAAAAAAAABxIORQkJCaE7ICNWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACcnIJY2JR09OygchAAAAABOMh51AAAAAFVKPzAoIBieAAAAAAAAAAAhGxYuEQ4OnhoWGkQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALSEblyATCU4wGRJjAAAAAC8iFlEAAAAAbE09IS8dGJsAAAAAAAAAACoVFRgUEAyLERUROwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmHBZ/CwgFVgYJBk0AAAAMCxEWLQAAAABfSj8YLh4cjwAAAAAAAAAAFRUVDAQLDW4LCwssAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcKCkgFCwsuAA8PEQAAAAAAAAAAAAAAAAwYGBUJDQ2BAAAAAAAAAAAAAAAAAAkJNgAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAC0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Dvergr Rogue"] = "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",
			["Dvergr Mage"] = "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",
			["The Queen"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///8O0LnQCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA59DQC9rIyCrQxcUWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsqWyFPXj4xzHrq4ppYyRM86qqhUAAAAA4sbGEufQ0BYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJl/mQq1k5Mm17KoU6+CfEq8naMq0sfHF/HQwibhvrQz//PdFwAAAADWzMwZ7u7dDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJGRow4AAAAAAAAAANmsrD7OkYppn2dvIP/MxjLesKNO4aekV+zHuimonpMyv7OzLP/z8xYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw7S0Ef///xGEXFlef1BJyIdCPciUTEagmVpSrsWEcEvfk485/7y2KnhNTLtMPzyxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/KioMAAAAAAAAAAB/f4oYUj5ImHFISf+aXlb0ezk282AxMPk5KCr8VC4lvP/GsjKmZGRCeDIz3ZFRTv9xLjBjAAAAAKqqqgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJQ1Khh2JCQcskxMCgAAACIXLhcLklJPV4VLRt2OR0fynEpF7KtcWOowDRDrO0M/6ll7dOgxIyP9Ti8moJVQSD+cNTLu3l1V/MlVUKHs//8OsLCwDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIsuJiGPKyspzFpVWqw/QLqzS0XyqElA9LNRTOyGPDfrOSUo7ycpNO43Sk/tIjcv7VFPRupFOzf7TT4zc808PLnzU07+zVNPpP///woAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHE0K1inOzz4pTg9+K5FQ+1hKiXsJRIP6hIUEfUZLjXmMEVS7AAbL+4iPT/tip+K6z9SR/kZGhm2pjtDfKo6Mv+hTUPJAAAAAP///xMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqPz8Yjz48x6s9PfN6LinqMhMU7QcAAuwLDRLzJCEm2j8/P0wAICeOKDRH/DJFTOppiX7tV3dl7UVGQO5HKSt1WSglyrpcV+3Vd3cx////CgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/MzN2WyUj/iAIDOkcCQnoSyUk8iQWF7hwW2YZX19fGA0aJr5RQ0/0ent061h3du17l4vsZ2ZX8lUsLOQlFxu3YjQz/ZReV2kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVUo2S081NI4wHSLeajY28oI9OvpNLCvvIiIpSbRvdDAyGxvVEB0o/FNAQ+q0kH3tUWVe7Vd5bu48RjnnOxod7yAQFfQbJCn5Mjw+kwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/Kj8MZzczRUcrInU4NCFEnUdKWW04P/KLVFTsjjQ0gx0TG8AqIyeJTSoq3CIMC+0jKy/efEdE771sYu1hXFLsVWtj8RUoId8LCAhWFxEW1QsTFv8kMDG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxFdQI5k7OF9bKCg4AAAAAAAAAAChLC+yolxY/4R4fL8AAAAAAwwNkg4ND/8aDAzQKSoioYuJgdurYV/ynj887YBwYuyssqPuQC4q6n9GPyQXIigsAgQB2BAdG+lXeHgmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFo0PCKDQEBbokVFCwAAAAAAAAAAUT0zGVsjIM+AdnndMUlX3ggIETwGBgAmAAAIXxcND3U/Ozb9npWK7XtRR+2wQkTxjUJB7phxZOqqSEH9iTcyb2xkcyFiPkw5PjxAcjtHRFYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPzQ8RBEiMw8AAAAAAAAAAB8fHxBKKyspSCgp0IWZn6AlO0WAAAQItQAAAAAAAAAAMCUq3mhkX/G2qZ7r39XC7bZiWu+WKzHveyss6cheVvuSPDVuh5alEScAEw2qkKEekJCQHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEIlLxsiDBaqqrnDZv///yQAAADFDhIORjAcHH1EQkT/pqeb6evl2O3///LtwJ6Q7VceH+1gGx3qw1xW95xER2+2ra0ct7ytMp+/tBijo5kZyMi2DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASh8lKUoZH3h9nrc9yen/GAICAlsCAwTmJCIk4La2sfDs4dHt//vx7v//9+2ampXtIyMp7TkVHOySSlHyXz88wVVzY8JegG7jVXZo24KKfdOUkXvRqZ+MsJ+Qgn2xoJQrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGHyYoRRodTQAAAAARRHcPAAAAAAECA8Nue3Txzsq469PJu+38/Ozt///67pyzpe00Nz3tHxAX7RkSGe08Skn0YX959hMxMPAhODPxp6OT86yjjvOim4f4wrmi/LOtlPKGhntGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/Hx8QAAAAAAAAAAAAAAAAAAAAAOHqz8XIwaX1yL2w6+nx3O3z+OjtpMOy7S46Oe0jHR3tAAIE7RcpJetmfGTrQVRM7CU6N+ysr5zrqaiR7KSXhen05tDljpKE9y89PUsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKioMz9G3ytG+q/TJvq3r9Pvk7er14O3F3cvtO1pZ7R4dH+0tKy3tP0U97Z6ZeO2Ee2HtJzky7YyRgu3KuqPptaSP7cnEsv95gYGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQzL2vtqGW+bKolern6dXt3urX7c7YxO1egXntFTdB7TVVWe1MZFbtwruZ7bKhg+1ET0fsbHNq68S+qf5zd2vhO0NDYgAAGQoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMHCsq3MwLD5xLmm6vXt3e3o693t5OjQ7Y+slu0lVlPtG05M7T5dTu3DwqPtva2O6nV3Zu8sRUrxRVxcpQAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeo2VXqqqpf/ItZ/o8ufP7evq2e3k6c7tvM+17VRxZOtTcGLqaHZj6szDo+jFtp36a3dw4wAMHjsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATmR5qJuOiP/Z0bHn4OPO6ePiz+rL1sjteY2F9HGFePnf4877ubSd/G1wbtIVNUdHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC8QN0dWvVhiZf9mfYL9bY2X/Vl6iPA0UFvSJUVRr26Dg5lQW1hZAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADio8WQowRngALEpcAAs4LQAAFwsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Bonemaw"] = "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",
			["Lava Blob"] = "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",
			["Fallen Valkyrie"] = "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",
			["Charred Warlock"] = "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",
			["Charred Warrior"] = "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",
			["Charred Marksman"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAgeEhISKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBTEDBQWGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAECAasAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASAgMD0gcPDyIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4BAwLhCAgIPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAtYFBwVgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQICtgEDA5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFSolMBMzLCgAAQGXAQMCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0SEjcTGxjNJTEs1QQICLkAAwLcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiMi1vDhISiQsQEOURGxfyBQoJ3AADAvEABQUvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuLgsAAAAABQ4M2RIeG/AJEQ7DAAIB/QAEAmkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDQ0TEA4QbAwWE5ISFhbnHiYh7xokH+AAAQH3AgYFuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUKCi8bFRX5FBIQ+wcPDe46PzbtNzYu8AAAAO0FBgXyHSwnNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwkPVBcbF4wzJh/ZGg0L8SsjIe5HLSfnBAIC6AECAfgRIB2/HDgqEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCAqWJCskIyYnJcdmLCTzTywk5CYkIdAGBwXrAAAA6QUMCvMXMyk3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACRMTGgkQEGsAAAAAMh4eTCETE4AcGxjwBxAKrgECA/EBAAL0AQMD9wMLC0EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGGhMnChsXSwAAAA0OFBJ8AAICrAAFBvUKDQ3SCg0OqwABAb0HDgvHCwsLFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYbFEkKHxoxAAYGJRUYFfEXFxT8AAAA5gIHB/gLDg5YBw8PRAwYE50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABRUTgQoaF0wAAAAADQ8MqCwqI/YNEQ/hAwgF2QUNCpgAAAChAQED3QEDBpwAFxcLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCgqZCA4M4xEWE8MECgirBxANygEAAbYAAwL/AQQE3wASEg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkVE2oFDg2/AQ0JpgkTD1ANGRWCAAAADQADAe4ABATUABkzCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBoXWAUSEYcBCgmoCR4YUw4iHFoAAAAAAAQCcgEEBPMMGRkUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDgttBAsL5gIHCK8IFxOQDyYfcAAAAAAADgASAgME8wIGCW8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMPD1EECQnnAQcHiwcQEqoKFxPCAAAAAAAAAAABAgSzAAMDigAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA4ONgcREK8ECQk0BQ4PkAQQDb4AAAAAAAAAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMGBgpEiUjbAAAAAASLCRFDCAdjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4LHx6YAAAAAAoeGTMLHBiHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHHBUkFSwmsRQuKsYXOS4WAw8MVAseGbIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAiIF8dNS5pAAAAAAAAAAADDQ1JEywo/yVLQyIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODhIVLixtGkM1EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Charred Twitcher"] = "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",
			["Volture"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6+vXDdPdwDXb28052dzKUuLr0zUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB3i3BCcYNpmXeDapenq5en0tjCftPdx1MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsqHmUgNij6PVNB1lZrVIV/jnaKvsewN/Ly5hXg59AhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABRQPMxMkH+gXKiPKM0o4vEVbRXJufGNKo6uVpNXbyKXx+OMlAAAAAAAAAAAAAAAAAAAAAAAAAAC2wqoV1dvBT+bw1zQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU2BbPSo5NN4JHhTUIzsslkZYRM1td2Gltryps93j0oP///8MAAAAAAAAAAAfKyVSSVlGrnB8Ys+orZPR09W95uTq1lgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGSYmOwgXE7oIGRLaGS4ktDpOPbNVZlWkn6qZqbC+pmuxv6tZSFhNmB0sI/pBUT36dH5k7ZGXf+zBxrH3z9W+vf//6w0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQNCnUBDA3NDBsW30NfSuamvaHem7OV5W+Mc/5AV0b6HjIg6l1sUuuRmHzttr6p7LvFsubW2MWXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRnWFGRl4H2OVVA62N8a/CGoInvKko16YGNgOqRmonuV2ZP6Wd1WumepZDtyM276/Hx4zgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAn6qPvVtlTv8KIhXoCBgT7w8nIewuQjfsgY167rG4pOvG0bzpn62Twaitl8XR08B26f/pDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIyQezxkbVilAAEGqgseH/oFERDeBhYV8RUsIe06TzrjZ3dg3qSuleG7wqfn0trC3+Xr1YIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhYV5FQAAAAAOHCU2QFdZ5UJWUTIGDgx4ChoV+xYsH9tFWUTcXmxU4nR+YtK2u6S66PDhReDgyCHk59hV7OLZGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACFopJQcZR/JAAAAAAHERGvBhoW8howIOg6SjjhaXNe0IaMdU6OmHttwcas7t7gze3l6dh3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgIFRLaCh4Y7hwtJPA/UEDBVWdRwniGafKnsJO9xs233Nvizrzk6tVXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMLC0AIGhfzCRsT6xotHu1AUj7bW2xT1niIbq+stp2YyM243Nnfydzh59J53uPTL+rq4BkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMlIHQdLSf9ChwR6SAzJOZJXUnPWnBXyHeCatGvs5vmztG618rOtu7d4svg5OzRYNTUqgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEZWUIU8TUX9BxoT6B80J+BFXEbjZnhh2HOBaZSFjXPZtbidys/UuaHU173A4eXGcOLUuBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGh4bXBHWkrzESMZ6ik8L609UULASVtI7mx2Ydp5f2SGqauRrNLTuMHX2r3E6+K+WwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGd2Z2VXZVrYDBsSyhYnHvYzRjneS1lIy2ZxWMyAiW2Tra6Wss/OtNLY2La05OK8WAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFViX0tHVk7sFCEb8REkF+4sPjHVTFtN0F9sVuGEim+1tbWbud7iyqrq7s9LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRzaTM6S0HeCyAV6hInHOgnOjDjTV1H4Gd2XJ2QkHRTtrKNatDIoHnm15w0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADpQQSMkNizPDiEZ+xMnHecxQjTQUWFPzoSFbbG8u5212t3Dy+fjvILd3bseAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgzKBkUJh6/DSEY/xcsIO8+VD/pU2RIoomQdW/Axati1dKoRO/PrxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQ2JA4QJh1PFCsgV0hfSGZjdlydlJSAo8C/puTZ2bzl6Nq9Wv/SwxEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8/PcFt7eyF7i18Jt/9rIDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Morgen"] = "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",
			["Asksvin"] = "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",
			["Lord Reto"] = "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",
			["Fader"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFy4uCx8yKHAJHBlRAAAAAAAAAAAAAAAAAAAAAAAAAAAADw8RBg0NJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+SzteGCcf/xomIfhFXk2sESsjOggICB4AAAAAAAAAAAAAAA4CCAhdBQsFLgAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACysn8KYWhQTBcrIdoCDAfJDBMU8BEdHdgDDwtCAQMC1gIDAsUCBAS9AAQCrQACAroBBAK9AQMBpgACBHoAAgJxAAICYAAAADEAAAAYAAAHJAAFBSsADw8RAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzQDKiESQg/h8qNRgACgpHAAAAKwAAABYBAwLiAQIC2gEEAuYECAf/BAkH+wIFBfsDBQfvBAUG7AMFBv8BBAX+AgMF2wEEBeYBAwTiAQQDqAAFBS0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYpJkMbKSb9AA0LXAAAAAAAAAAAEhUVUwECArkFCAfwCRIP6AcOC6IMDgxpAAMHgwEHCowDBQWMBQcHjwUGCJUDCQmDAgYGcAAFBTMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKTYwTxcoIv0eKB7XxrONNgAAAAASEgx9BQcG9wIFCKsDCwtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPLx8wFikh+yIkH7uOjGmRKDksfQsRC+AGCgiVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f2oMAAAAAAAAACofKCDxNzow4y87K94YIx7/AgoIsAAAAAAAAAAAAAAAAP//7g8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG5uWBeclnIxDxEOkDhAMvxfZE3sNEAw7w8eGewPGRPbHDAlozlDOYCalnGvYmlL3k5TPJNDVzwmRGBPLQAAAAAAAAAAAAAAAAAAAAAcHBwSChUVLwcVFSMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvb08QiIhmDwAAAAAAAAAAAAAAAElQO448RjX1KTkq7DY9LOw5RDLsHy0j7BYlH/AhLif7LTst/Rs2HvgABgPyKT0m+DZlQOoJIRPTCxERgwYUEG8GEg1uDhMReAwRDmcFDw8xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEpVPxhNV0J6f4VkVHt4XEhXXktpQUo3szBBMvEhKiLrKTQn7QsiE+0JERDtCx0Y7DU1Luo7TjXpDU0h6wsUEuwlNijlNGQ++iZ/QZADAwZNAxEKSQAKBTIAAAAWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApSXUOnTlU6Ti04LogaMynHKDUq8RsnHewSSB/tBRkJ7RogG+0gKSLtICMg7R00Iu0xb0PqAwoG7QcKCvMPJBf8G10wgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGZzWDdXalJg0sOHERQjGTM2RDHcQ047xRcnHtkvOyzxHzYh7CyoTu0QTBvtFCMa7Tw9Mu0LFRPtEjAi6yJGLPoECwlwAwEBlwABA/4AAQGeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH94VyZsZUqNKjUiqDE+ML9NVTzJSFI8sBUiFvdpclf1LDMo8T1HOexFUDrtJp9H7E/LbuoVOyPsAAIA7AoSEuwMJRzwGVMz5ABEIg8ICAgfAwgD+QMEA6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWks8EQAAAA0AAAAAAAAAABYhFkQ1OiyPPT8vsry3ke5UZkfrERwU70ZLOt0mkEHilv+u/lKPYvQgLiD1AQMF7gcVEvAHLBfZACYMFAAAAAAFFgdkAQUE+AQJCTcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBh2hTmZ5t7y1gNOsSUivwHC8h/CliOZiI/6ulQZJTUjNAK8InLyXOAQ0I8gQaE/sAExNBAAAAAAAAAAABBgXlAAcHbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEdJN6BCZjv7JHM78B9KMNQFDw+3Fx4ejQAAAAAAAAQ2CRoWwTE3MOcABQJiECQX7AQRDpwAAAAAAAAAAAgTD5EEEAtuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwZlEZKTcnvSh7QuolTi7oAAAAJwAAAAARHBahCxYLFwwrHykDEhCXDAwMdwAAAABTXEilFiobwQAAAAAyRD1HKDgv6gAJBG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIR9XUdaY0aFEzcnrhcoHpcAAAAAapRqDD9JOpEAAAAAAAAAAAAAAAAAAAAAAAAAADhGNqcUIRmeAAAAAD9VRDwqNy48AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfXdVgGBgRVUAAAAAXm5NLgAAAABmZk2EMTwqSAAAAAAAAAAAAAAAAAAAAACZoW48VmRK6yIwLKIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpnSEpERCg4AAAAAAAAAACPgl0pgXhXdFNTO18AAAAAAAAAAAAAAAAAAAAAp6eHIHiAXe49STf/CxMVzQAADxEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiopqGH1wUz1XUDojAAAAAAAAAAAAAAAAAAAAAAAAAACBk3Q5Lj0qlQAAAGwAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="
		};

		public static readonly Dictionary<string, string> TrophyIcons = new Dictionary<string, string>
		{
			["Boar"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACLc0ULAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoHhKf5t0ScGFY0IXAAAAAAAAAAAAAAAAAAAAAN62gT/Kp3eJr5FlOgAAAAAAAAAAAAAAAAAAAACieEYke1s7rz8tHzgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKaULYonhO/41sRMZcRS4hAAAAAAAAAADNp3Vmzqx79MSldv+kimXyemZMZAAAAAAAAAAAjmlDIp1zSM1aRC//FxMRggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIVkQYSRbEX8lXBH/4BgPt2BXj10pH5Sf7eUZ/y1lWr/qYpg+5+DXv+Ib078fF5BeYJgPm+Yb0fdj2lD/y0jG/wYFRVqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlXJIdJFsRv+NakT6k21G/5JsRP+kfVD/pYNZ/6iGXP6mhV3/mHpV/opsSv+GaET/kWxE/6F3S/9qTjT9HRkW/yAaF1cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACVdUg/jWtF9YhmQv6RbEX8l3BG/Zt2Sv6gflP+poVc/6mJYv+VeFP/iGtI/n9hP/6FYj3+kW1D/Es4KP8XFBP1KSMXKwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIVtPBWQbUbYkW1G/pFsRf2ac0j/mXNI/5t4Uf+jglr/pINc/5V4Uv+IaUj/gWJA/35ePf95XDv+OSwh/hoVFNMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI9qR6WWcEr/km1F/KR9Uv+gflT/m3lR/558Vf+bfFX/k3RQ/49vTP+OcE3/gmRE/2tQNfw/MSP/HxgVnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf2Y/KIRiPtuXcUn/mndR/aSFXv+gf1f/l3ZP/5V3T/+QcUz/mntV/4RrTf9VQzH9QzMl/ysiG90aExonAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiGhBfZNuSP9wUzX7el9A/56BW/+WdU7/lHVP/45uS/+UdlL/TT4s/ywgF/wmHRn/HRgWkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACVbki9jWlF/3VWNP1+YUP/tJ+B/5h2Tf+be1f/q5Jz/2lVO/8/MCH/VT0o/Eg2Jf8zJx7BAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoH9TLph0TvmVckz/hmE8/5Z6XP/HuKD/k3JJ/41rR//BsJb/YFND/0g0Iv9iSjH+Z082/ks7KvosIhtKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACdfVVuoH1V/5p6U/6SbUb/pYZm/9jLtf+QbUf/eVg1/7ysmP+Iemb/WEAn/25VOv9uWDz8Yk43/z8yKJkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKJ/WKiefFT/mXlR/I9qQv+qjm7/8OjR/4xsR/+Ka0v/2dG5/3VmUf9ROyX/YUoz/2lSN/5iTjb/Mikh3gAAEw0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACeg1cdm3tS35l5Uv+VdEz9j2tE/517VP/JvJ3/h3JX/5BuSf+HclX/UkEu/0o5KP9ZRC7/Ykw0/1pHM/4rIx3/GxgVVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJF0SCOMbkfnknNP/5V0Uf2Tc03/j2xE/4lrR/+McE3/j3BJ/3FWOf9TQS3/RDUm/1VDL/9cSjX+PDEm/iAbGfQgGBQ+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINkRGWJakf+i21K/Y1uSf+Uc0v/lXJJ/5NxSP+Xd0//gGRC/0k5Kf85LSL/LiMa/yEXEvsjHRn/HRcXgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBjQZ9/YTz/impI+5FuSP+ScEj/lnNM/558Vf+FaEX/WEUv/x4XFf9NSD37ZV1R/yMeG8kXFxcLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACpiCaczNvaP/moBf/I1rQ/+Vc0v/m3hS/4BjQ/9qUjf/MSUb/lVPRP+JgnDfTExHOQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD29u066+rck97b0c7Wybb+jWxD/pZ3UP+dfFL/hWpH/2lRN/5ENyn+GBMT0QAAAC0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMnErjns6eFe////5uLTuv2dcEL+pHFJ/6JkP/+bYD3/e1Ay/V9NPf2NiHaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///7P/////waaF/5RTMf+aUDL9lEwv/ZNML/2XSyv7lWRH/9/axfzTz7hBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADn5/MW////1+Lhzf+BYEndjUwu/69cOf+nWzf/nFMy/6NXNf9sOSHU5uTa2ufl1MYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///z78+ev/jYx/yko5MR+RVzdmgEYsuHQ8JslsNiO6WzQjjhIAABz6+u06zsy7iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8OrfWLGvotcxMTcpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4OCoSERoaHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Deer"] = "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",
			["Eikthyr"] = "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",
			["Greydwarf"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANC/nCzNtZBsrphzpHhiQndjUDcpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADJrYB34M2n68+4kP+okGv/e2RE/1tJM+pAMyOWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMqyib/l0qv/wKuE+ZWAXPxzXkL7Wkoz/zswIv5YTjEaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADy5s4VxLGN09jFof24on38l4Je/2ZTOP5bSjX9OCsg+l1MNzwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOLUvyTNupvrzsej/6mlff2WhGD/VU82/0ZHM/87MSb/V0YzWgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1ciwm869n//Avp7+tq2K/7WffP9nW0X/Mjgs/Ts1LP9eTT2lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOzfwCnCr5Dsz8Cl/9TGrv3by7L/4tG7/7umi/90ZVf+Pzg2/kM3Mf14Yk5OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC7Wkkdju5NP/7uXY/uvg1v/m2c7/386//8Kppv1+a3L/PDI37SolJTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6c3NLz8Gw/uXc3f/b2Oj/5d3e/93Nx//CtMv/rKna/pyOsP5dT1f7RDk5SwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyhjl3aybT/v7nW/9LY+P/q4+b/0r+//6qiz/+pv/v/trLY/HBfaP85MjRvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAd3FrLcm5pu7Htr3/wbTG/uDRyv/Is6z/gXOY/11ep/6AcZT/cF1h9zkxOUMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhnRpm3hlZf9zX2f8qpSI/6yXiP9QQlL/LydC/D0xQP9SQ0SrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhTj5eW0tA/2NRR/1sWU3/YFFI/yghKP8gGiH9HBca/xsVF3gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIdzU0B1YEf4Yk8+/1BANP4mHx7/IRoZ/x0XFv4eGBX/JBwXYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWlI0Im9dQeJbSDX+Rzkr/SkhGv8cFRL/GxQR/h0XEvsjGhU6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFOS4WZ1c83VtJM/9BNCb9LCIZ/xYRDf4bFBD/GxYQ+RQaFCYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5ZkZaVkQv7T0yI/4sJBr+Ew8K/hsVD/EgGBNnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8MSGPPjMk/y4lGvkTDgv/FxINrwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4lG3k8MSL/LCMY+RQQC/8aFA6iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANSoedzYrHv8iGxP4FhEM/yEYE5oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzJxxzMCcb/xwWEPcaFA//KiAXlQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADkrIF0mHxb/GRQO/R0WEf81Kh9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwZEG0dFxD1GRUPdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACcfF0EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Greydwarf Brute"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJaiURbFv0aJxr5DWwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu7tIMdDOS/LFxEaGAAAAAMzMRxnHx0Jzybs1EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZlbGZmlchQAAAAAAAAAAMPDWCvIyDYOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMR1GgAAAADr64kNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABzc0ULR1cfIAAAAADD0ocRAAAAAExjJE09RhodOEYcEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFwAWABgANKqqcyqNhVZnR1MiaCRbEg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANi7kDWunnOusJ1066WPav9pUzflVkYwmT4xIU0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACTeEMTzraI0ujSqf+1oHn/kn1b/1pIMf9TQy//PTAi/DwxIS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMSwiSfIsYjn2cek/bihef2Nd1b/VEIt/lFCL/w3LR//SDwqVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2cmoPseyjPbQvpz/sZ10/o96WP9IOib/Wkk1/TcsIP5KPCpxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg0rZb2MWg/8C/mf2ponb+kn9Z/zs6I/9ARy78PjMl/1VALooAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+PHWJt7MrMnRwp7/vryW/bushP+xmW7/Ukct/zM2Iv06MiL/WEUy4JJ0VjsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSwqNtzrWN/9HDof7Pvpr/2sml/9vGof+liGL/Z1E3/0c3Jf1BMCL/ZU87igAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH1ZND/LtJL87ODI/+zgyP/p2r7/6Ne5/93Env/Fpn3+hWhN/koxI/4nFRJUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAooptheravv/y6dr98ufU/+fVt//m0rL/3r6c/9Ocdv+0hGX8c0w3/1pBMHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFr42x8M6w//Ghj/zzrpj/69K2/+DDov/hkHL/6n9o/92HafyKW0T/VjcnnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALSpj5vrsJD/8ot7/Penm//qxKj/2LaR/+F7YP/8npT/7Ilt/ZVlSv9LLiB9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAq5qIVuHCnv/dkXL+5KaJ/+XMp//Fn3n/p1tD/7RHNf2rX0f/kGhQ5Vc6OiMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEo3wnimxQ9nVRO/+YcVL/yKmA/6eFZP9cOCj/RiQb/E0tIv9dQzK2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhRC+9Ykcx/2xPNv17X0H/Zk85/yoZE/8qGRL8IxQP/yIUDZUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINtTH51XkH/X0k0/Eg4J/8nHBT/IxkT/x8VD/0gFxH+IxsSegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcmFBWW5ZPv9TQC3+QDIk/iEZE/8dFhH/GhMP/x8ZEv8fFxFYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgUzo9a1g8/E8+LP9AMiT+JB0V/xgSDf8bFA//HBYQ/BwUDD4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0XkGMTD0q/z0yI/4jHBT+Ew8L/xwWEP4hGBJ7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxFLgs9MCHcOzIj/yUfFvsRDQn/GhQPuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAmGcg7MSH/JR4V+xIOCv8ZEwyhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCocwjgsHv8hGxP6FRAM/x8YEZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2KyC3Mikd/xoUDvoXEQ3+Ix0VkQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUqHrYvJhv/GRQO+B4XEP8vJhuSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMycebh4YEvsZFA7/HhgR6D4xJE0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGxYQbx0XEOgZFRE8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyYYNQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Greydwarf Shaman"] = "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",
			["Rancid Remains"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlv+WFofuiz6G5olqe9N/OmalWRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAm/ubRZf/ob2Q/5vXiPOR8ovwjv9yzHHyVaRX1VaKXL9TZlNSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkOaLNZrzlZaY/5rvmP+e/439kv+A54H/dtd0+3XRdP9nvmz/U5Na/0JXQ/dTUk6VWFNTNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAInEdRqS2oPho/2Z/6D/n/+b+538g+aH/HLOcf511m//iOyD/oPihPxWmln7P1lA/1taVv9dU1nqVlFWNQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe7tjiJTggP+W74z5n/md/q//sv+I2I3/abNp/3XJbv+i/5z/kvCT/1+gYP8/WED+R01G+VROUP9LQEajAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHG7ay1ts1rsf9Bt/o7ph/2c+Jz/meqd/22sc/9BdkH/YqNe/5Xnk/+G2Yb/YJ5j/z9bQP8/Tz/+S1BH/kQ+PPUvMyNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAa7ZfcG68Yv+AznX7n/ec/6X5p/9Tm1r/I1Yo/yNKI/81bTP/U6FR/2a8Zf98xX3/Xopc/05lTf9SXFL9REpC/y86LYcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlsFtiabVh/n/Gevx8xn3/Yqtp/zx6RP8tWi7/JEUh/yJLIf80czP/U6FU/1CXUP9JeEj/RW1N/0NkSf09Vj7+OEw6iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGa4ZldLlUr/KGon/RxlIP8dcST/LXsz/zBqL/8hSh3/IkEd/x9PHv8paCz/KWkt/y5wMP8kcDD/I2Yt/TJeMf8/YT+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAddF4TkaPSfsSVxT+QJtE/l3SZ/9QvVT/TJ5K/zpyN/8lRhz/LFko/yhfLP8hXyb/R6pO/2LTcP8mgC/9J1wj/0JsPnoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB83HlSSpFC/S12Kv5gyWX+d/mC/2jgbv9xy3L/MG0w/xY/Ef9Fe0X/OnQ4/yxqJv9Xv17/f/WK/z6WQP0vYCr/P3JBeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHXSazRitVrtVahQ/1y+Wv5Yz1r/atNo/1CWSf8WQBD/ETYN/y9hMP9MjU3/OYM3/zaKN/84kDz/K3Mt/zhpOf8+b0FeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAW7tRNYvqiPJ71nr/XLNW/l7HXv9hul3/M2Iq/x0xF/8aMhr/I0oo/0qHT/9GjkX/NnU1/0B+QP8+eT/+Pms+/z9hP2EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACY8pNokOmQ/VaiWfw5gzj/TalR/1+tXv8YQRH/IS8c/zhMOv8ePyT/NWQ1/z90OP8rXS7/O28+/0d5RPxBYzr9RVdAlwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIbFgZJTh07/HUEf/hlFH/9DikT/cLxq/zRpJP9MZjj/Q2E3/z1hNv9KeUP/OGo0/yRFJv8nRyr/Mk8x/j5TPP87SjqvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZItcITtbM31FXTzrMUsr7E+VSPSA3Xj/keCI/12SU/9HdDv/f7hz/2uoYf9FckH/KDwp+Cs2Kto0PTDxP0k/gDpORBoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGODVbMoRB7UaLNj4Ifogv6M34r+OHA3/zpwMv+P14P/XZ9R/jhZMf44QjbyKzEquykuJs8iMyIPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXI5Vjz5mOsx4vni9d8t5/0+ST/knVyX8M2ou/GmkYvxLe0P7NEot/0ZNQNI0QDSpKDYpxBkZGQoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsqmBnhcR99o/Zkl5zwXfcfcyB/3/Cgf9qomr/RmdF/zdJM/86RzT/SU8/ZDZBL9cyPSynAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHu9ah9vt2rpaLRmr3bGfWxst3V1WJRdcylVL4wWLRt6NDwxXTxIOG0vNSWVMTgo+jVBLT4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHbFcW50x2//fsx+t53kpGuz7r5bqNOvU3ebeVpIZEh3OUoyqDhCLv88PzCdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAov+LC4nZg8d2ynT/VKBX/1ydX/9QglP/N2A3/yVHI/8xSSz/QlE66jxINioAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfMV1UH/JevhVklD4G0kY+SJOH/xUfVP7Kkwp9ylAJv82RjSCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUX1MrUltQ/8gORn/JEgg/1ByTf8sRCr/NUQz3UdRRxkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbKRslLjormCYyINUqRyb0OlY24io7KKI/SD84AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJC0kHDFFLYczTi9BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Skeleton"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/4Joh/92SNuvFhXPfwINytJltOo5/WiIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/3aoP/+Cdjf/iluL81Yvy8suF/+bBf/+xlGT0lX9Z5HBjUaxBQVAjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3aN/cvS/jtb/4Jr//92Q//DGgf/atXb827R1/NKscP+sjmD/YllN/0xNUOJXV1eDT09PEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMOOdETjqoP//c2W//3qpv325qD91rN6/semcP/lwYP/+tKQ/smpdP1jWU79UlFU/1tbXf9NTU2BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt4Rkvt+oe/71yIn7/+Wg///sqv+7n3P/oYdh/+DCiv//4qL/v6N1/2dYR/9GQD78TEtL/EJCQuMvLy8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALWHX1OygWL80Jhw/fnJjf772Zr/tphs/2dYQf9gUTz/r49i/9CrdP/EoW7/jnhW/1dRSv9TUVH9RkZG/zMzM4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtIVdbb6MY//gr3j8+taR/9a3df9tWTf/STsn/0I2JP9wWDf/o4BO/8ifYv+hiFj/d2hK/2leR/xTTUX+Pzo3oQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwg1ZbpHpQ/5x5QP6IZyr+gV0f/3lcJv9dSif/QTMg/047Jf9uVzP/hmo3/3leKf91VR7/cVUi/GZRMv9YTDycAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMiXYVSMZjr9WDsN/pJmDv64gxf/qXMb/4diJv9SPiP/STUh/1I/If9iRxr/iWER/7eKG/+PYw/8Z0kb/29aMpIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3q5sVYpnPf17UA//67M7/v/dWv/vqzL/xZBA/1A+Iv9eRSv/gWMz/2lLFv+wfBD//+hY/8qXJfxtShT/dV0wlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADdrGlEqIFO9LB6Lv/fojP+77M8/+2oPf+PaDH/NCgZ/0g0If+OZDX/j2Mh/51uEP/GkR7/nG0S/HJRHf+AZDR/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALuQVjXowH7v0aNh/8OJN/3foT7/vY1B/1E+I/8sJBn/OSsg/29PMf+oeDr/hWAd/4dbFf+BWh39d10y/25cPnYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8cqPYvHPj/2wkl79i3BB/sCYV/+YeEn/KyUc/zouJv9CNCz/Rzkt/39fPf9mUC3/eF0t/4ltOfxtXT/+VU9EpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSqnuOjHdV/0A4Kf5JPCr/pYNR/6mHW/9MPTb/aU88/11FNP9mUEL/dFtG/01ALf9IOyn/UEQy/lhMOf9KQzzHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI92XSlWSkOQUkU/8k49Me2ogVX75rp8/9Wmcv9vVUD/nHlY/72SZv+OclH/RDwz/jkvJ+M6NDPwRkBApkhCPCoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+X0vBSzsxzsWbZ/bzxoX+w6Bq/0g6Lv+rhWD/zqdv/3NgRP9DPjr/OTEvxy4nJ9ozLTMyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIdkTKB1YlC/yaVz0sejbv9+aEj+VUYy/pB0TP6afVL/VEc3/0dDQfVHREScMysq3jglJRsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAr4Bed8iofe3OsYVjv5517cCheP+4m3D/fWlM/0xBNf5GPjf9S0VCi0A8N645NDPPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADHj28gtYpi6reMZbLGqIBnqpV6S2tgU18vLShlPTk1R1FIP1U7NTCJNi8r/js1M1oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADOoHJ00qZz/8yseMPVuIab4MGNkKqTbYpmWEShTEM0vUU9NflCOjbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOm/fwzcuH/OvZxt/4pwS/92X0L/bFlA/1VFMv9BNSr/T0U4/U5DP0QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALmdc1SzlWb9dF0++y0iG/h1Vjr6clU4+D81Kf9DPTKmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFNKPKVGOi7/LiMb/2VHL/9TQC7/Ojcz1FVPSS0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMnDTYvL0Y1LCOVUj4vs0M7MF4sLDcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Ghost"] = "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",
			["Troll"] = "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",
			["Bear"] = "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",
			["The Elder"] = "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",
			["Serpent"] = "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",
			["Abomination"] = "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",
			["Blob"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKeTXSbQwIcxsaSBO45/YEKOgVo7enFLGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJFOMZqTPIenl1bDtaRt5qOTYOpsZjvrYFwt8HFpQvN7c0PbYF4zmmNcTE0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMSydXGhk1rumpVF/6afUv+qmmf/b2VF/29rPf+CgjP/bmk0/3RsPf9vbjL/Z2BB/4F1TLuKgVU5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3rGB8tKpr+aKRYP+WjFH8h4g+/MXAg/3h4Kz98+yp/vLbmP7at4D+lX1Y/WlrJvxpZDX+cmdE/19dOt5rZlEyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw7hhL7GuXPajmVr/mIhb/puLXf+vrHL////S////x///9LD//uGh//bOm/+8nYH/b2o3/1JRI/9aU0L7UlQv/1ZWOIcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACpq01fr61T/76qaf2Nf1b/mIRU/+zTnP///+b//P3T//3xuv/746z/8tOk/8Cih/9yYET/R0Qc/1xXR/1UVDL+Xl46vQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ+hSIWcl0r+pZNg/XdrR/97b0D/3cyX//34xP/998f//vPC///pt//zzp7/tZR4/2NTPf8+PRb/Uks0/lZUL/9bWzfib29fEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArapRqaSeXf+Adl38XFQ7/21mM//cvoT//9uZ//zZmv//4qv/7sOT/7qRaf+UdV3/XU03/zo7EP9DPyj/T0or/1VWM/lqZFowAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANS/fwyzs1TLlo9T/29lTvx7cUz/gXtB/9m3f//t1aD//+yw//3cqP/Kq4j/po1z/5qAaP9tXkH/ODsQ/0lFLP9bVTv/V1Yz/2RkS1QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAopBcLJWUP+mGgTz/mopj/ZeMXf+BfUL/alhD/zIsJf+KeWD/5LyP/5R9Zv82MCz/LiUi/2hZQ/9BQRr/SEIr/1xTPf1aWTj/X11ClgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACrmGNSkIpF+nV0L/2unW/+nI5h/4Z/Sf+gi2n/Rj0u/0E2J/+eflz/T0Az/xEPDP84Lif/gGxa/0lDLP9BOyj/UEo2/V9cQP9iYka1c1xcCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKKWaBahlFbanZtI/62eaPyQf1n/aV4+/459W//Qsn//27V+/4VoSv9xXEb/jHNY/3lnUP9oWkb/SEIv/0ZBK/9PSTL+W1s+/2ZpSlwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALOjaLejnEz/hXxE/FtQOf9nXT3/V1Mt/4NxSf/ovYb/47V+/6KFY/9/bFb/OTQl/z05KP9HQyr/RUYe/0pHKf9bWj77X1s/OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt6VvjJ2RUf9WUib9YlY7/4V4Sv9XWSH/Y1oy/9arfP/csX3/pYdm/31oU/88Nyr/PTks/z46I/84PBH+Tkwu/15aPuVGRhwSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC7p3hMfnNM91ZPLP98bkf/koRZ/0pJIP8/QRb/loBa/5R9Yf9xYEv/T0Yz/0lGOf9OSTj/REAh/z9BGf1cVz3/YFtEvgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHhpWhFiWjzKd2k//4h6UP6Hf1D/S0wZ/05OIP9YUjf/T0k1/zw6LP81Myb/T0w8/1VQOv9ERBv/R0Yk+2dhSv9lYUuKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAId5S4CRgk79koNP/GFdMPxFRRf9SkUp/kQ/Lv9NSDf/TEYx/0hCK/9IQTD9TUct/EdGIfxQTTb/WlY//FxVPUIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmY1VLaiaZ9GAdUz/UU4i/0xKI/9aUjb/dWpH/XdwXv5QSzj9RT8p/UdBLP9WVDb/YV5H/11aRe5ZVTqDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnZJxL2JeSoJiYjCzZGMw3HNrSPlsZEj/UU4y/01NLv9RTjb/UlEx6l1fOrZnZVVsYmJBHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABRZC0cXl5BRmFcTm5fXz19Z2lAe2NeQWFiYjksAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Draugr"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJwcgWV5CNnuDaR0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//nxj/9JVj5diHi52XZ9xdXELuVlQ62VlYOZ+srIMfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADv328Q+OeIw/fmiP/UyHn/qJ9p/2BZNf9iXjr/endO/4aFU/GSkF+rZ2FJXjMzKh4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//+9L/bnjMfs03//ybhw+46GSPtnYS79aGIy/m9uPP1jZTL8cnM9/4OEUf9vbE//REY830BISEMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHNzRSG3tG7J2cx//7CaX/pZTSL/Xl0s/3p8R/9sbDr/YGYv/2FmMP9iaDH+Ymc3/EJFLPo+QjX/ND027CMvKpcmLCYuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABbWzMZcnJBjIJ9Tu6Kgk78hnpF/oN7TP+Qjlv/gYRO/2RmNP9dYjD/Y2Yy/2BgLv9iYjb/TU8x/zk7LvwoLCX/KC8n/yIpIpUoKCEmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJKXYS98fkzFfntP+nZvP/6qn2P/xLt//6KbZf+KiVb/Zmk6/1thNv9hZDX/Yl8u/2JfMP9gYjf/TE82/ywvI/0uMif4JisjxykuJTcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAb3VDlHt8SeyNilT/joZN/rCjZ/+ak1z/kY5c/5ORXv93d0b/XWM8/11jOP9hYTD/cnRB/3R7S/9ZXjz/Oz8s/zQ4Lv8sMSnwICcgpwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFpaLSJtcUCxgoJQtKqlaeyhn2X9o6p9/qy5kP+Mlmz/iIpY/4yHUv9xbkj/Xls4/1VVLf+KlW//oraX/3B7Y/82OSr+NTky8jM5LbcgKB+7HCMcJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcnJMFHF1RNx3eEbprKdp5bGtcf/CyJr+4fHK/7rHoP9/gVD/pJxm/2djQf9BPx7/cXRN/8PSqv/V7sn/r76a/1dbRP8uMirvKzEl4yEnIO0dHScaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0eUk7am08nIaETue5r3D/tqxt/pqYX/+ChlX/cHZI/5OUYv+Qi1n/NzgV/0FEI/9hZj7/folf/25/Vf9pdU3/VlxA/i81KP8xOC3uISgenyIoIksAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG1wP21xdD+ZqKVo9MW3d/63qWn/pJxf/5SOVP+IhFD/i4hZ/01MIP9GSST/XmI//1dbN/9eYj3/Vlo2/z1FJ/8oMxv/JTAc/jA5K/koMCWiHiQedgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAClpVoRc3U9km9xPOmbmln/tqxq/qKWV/+Kg0r/hX5J/3l1Rv9sakD/Xl43/1xfOf9RVDH/TlAx/0VIK/8wMhn/ISgQ/yAqFv8hKhn+JC4g/yozKfIhKB+YLS0lIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJKSU0mHh0yteHxE84iKS/2joF3/k41M/4aDR/+Bf0j/fn1N/3Z3Sv9gZDn/Vlsy/0tPKf9ITCj/WFs5/0VIKv8uNR//HygZ/yQsHv8jLCH+KzQp+icuJrklLCJRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABjVSoShIBHi4iKUcBaXSz9fYJK/oyMU/+Hhkr/iIZM/319Rv97fU3/aWxC/1tfNv9eYzj/V1sy/1dbNv9XWjf/TVAy/zg/Lf8pMSn/JS0l/yYvJv0jLCL9JisixicpJJMoKCgZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI6GVV+EgUvDbG07xlZYK/h7gEz/dnhF/3t6SP96eUf/b3BC/3F0Sf85PRf/Q0cg/19kNv9RVir/XmE//0RGK/84OiX/KS0h/x0kHv8eJh3/KjIp/h4nHfsgJx7JKC0ovicpInUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACPj1ZHkpJWkHx7R7ZXVSebW10t54WJUP94eUf+cXFF/3N2Sv9gYjn/aG1A/1pgNP9FSR//WV0r/2NmOP9dXzr/PDsf/zs6J/8yMif/IiUd/yMoHv8zOS7/Iyoe7xokGpsnMCa5KDAkkicwJFUAAAAAAAAAAAAAAAAAAAAAoaFdPI2LTq+Kikpnbm42sVhYKWJqbTnQiYpS/3d4Rv5tbkH/c3ZI/3BxR/9kZzj/dHhI/25yRP9scDv/Zmk3/0tNI/9FRiT/Li0T/z89Lv8rLiL/Jysf/igvI/8pMCXbFB4RZScwJKouOCptJy8iois2K0EAAAAAAAAAAJSQUDydm1yXmpZYQpOTWGh1dUBqYGAuV4WIU+F+gEn/dXZE/Xl7S/9wdEL/b3JE/3d6SP97fkv/d3pJ/3d7Rf9nazj/bG9B/1VXL/9BQiH/Q0Mu/zY4Kv8yNyj+LDMn/ys0KPQfJxpgHykcYi03KW8/RztALjcrjjA5KlmHg0dAjIlMp5CQUlqKhk57f39NSG5uP1hwcD6agIRL/nN1Qf52d0b/e31M/3V4SP9fYjb/c3ZG/32BUP9pbD3/dXlJ/2hsPf9iZTr/XV83/2BhPf87PCP/SUw6/z9FM/85PzH+OEA0/x0nHKMeJxxbICsdRi86LXUwOC5eLjcrmZeVV3RrZigyi4dOfnt5P4R4dTpOcHA7kXp6SMV/gkr/eHpI/Xp7Sv9qbD3/cnVJ/2RlPv9maT3/aGs+/2FjO/9lZz7/XmA5/1RWMP9TVDH/WFk4/zg5Hv9DRzD/Nz4q/yoxIf4yOSz/Iy0hzx0lGpsfKBtSJS8idTA7LooeLh4hoqJzC5KNWV6Tj1iCd24zHnp4P4xsajmxfn1N7IOFUf97fk3+dHdG/2VmOv9vb0X/eHlL/21uQ/9mZz7/ZmY//11fOv9VVjP/XF03/1laN/9DQyr/NDQh/09PP/8wMyT/KS4d/jE4J/4rMiTzISoesCMsH5ARHRErYWpcbj5IPIKwrXdL0tCYaJaWYid4dEC+bWozkG9tPZWAgFD/dnhH/W90Qv5wc0H/ZWY4/2JiNP99f0n/b3BD/19dOv9gXz3/XV47/1FSMP9RUi7/YGE9/0NDLP88Oy3/S0w//zg6LP8nKxv+MTgl+zE6Kf8jKx6eHygbiyEqHsg4PjMtWmNXWsPDjDOlo21kd3VAxmNgLppnZzAvfX1MfHZ3RvZxdUP/cHNC/2tuPf9wckH/a2w7/3l6R/92d0n/XVw5/11bPv9eXzr/Wls6/z4/Hv9QUS7/Ojoh/0pKNf8/QS3/QkYy/ycrHf85Py7/OEEu9yEqHo8aJBoxISodiiMsIM8pMyRpfX1KS25sPYFiXzZQd3pES1NVJoZ5eUuqbm4+v2xtPO1ubz7xbW4++XBwQ/9nZz7+cXJF/3JzQ/9zckj/YWA8/1tdNf9ZWjn/RUUo/lVWNv47OiD/UlM3/0dKLf89Qiz9LTEk7zQ6KPM0PCnJLDMprR4lGogfKRxQHSMaTiMsH4plaDmaZmk9V1ZbK2pUViVYTlAhYnl6TeFtbUCudHREyHV1RolubkDra20+/2BhNP9gYTX+XV8v7W1tQvlSUC/+ZGY8/kxMLP9JSC/3Rkcp6VJSNv5eYTz/V1s5/zE1IvkfJBeZMjgk0DU+LKYsNijnGiIVaSErHlMeKhxtJC4kU0hIHD9gYzRSU1olUgAAAACGilVygYJR/2ZnNrt+gEvPjY1ZdWlrO+dzc0b/YmM292NkOeddXTPVb25H+FFRKvdfYjX+RUUj+UBAI/hWWDbWVVYz5mNoOvdcYDv/KSwa9zg8MHo7QyvRLzoiuikyI/8kKyCMAAAAACYsH1AiLBxRYV48XGdnO1EAAAAAV1ckI2dqNPlrbDrhY2Uyg36CR8mEiUyta2w67l1dMv5KSCKzaGhB32NiP+FeXjbgd3lG82xvPf9TVDH3SUoo4lhZL+FeYDbhYmc4s11iOfsrLxb6PkEwo0BJLtU1PySFMjgl1SoxIvsRGgg5AAAAACIqF0I7OyKVAAAAALSqdBhQUCa7XWIw0nyBTZ5fYS9weHpG1oCCTdx7fUn/XV4t/1pbLct+flPZZ2c/3lVVKHiOkVrMbXE/8kJCIeJvb0xuV1kr0kdJH95aXzHCam9F/zM4HP8rMBzgND0i4DdAIXI9RSyQMzspyyIpHcAsMywoAAAAAAAAAAAAAAAAWVw1vzY2Enp2eEO9hYVR4WJiMYZxcD/scnFB8nh3RfVgYC7jZmc55XBwR6+AgFTXZ2c2T3+ASsJ1eET2PT4b3WNnQ0BcXzPWU1UrpWptQ+tcYTrfVFo89zQ5I+4+RSv1KjIXgzlDKNQ3QCfPJSwccyYuIb8vOCUbiIhdR11dO3M+QiRFQUopH3x8S9V4d0OcfX1LcJCQWf+OjlflbWs69FVUJbxlZTrWQ0MfSF9fNbVjZDPdb3A+yWxvQMtWWDLMW1w40UZIIc1hZjc3cnZM2lNZMbRZXzz5SVA14UZONP8pMRuCNT4njzlCKuMqMRwkISoXNigxH3FaXTjzNjYbVQAAAAB+e1K8fH1T/1peNIdgYC+mmZpd+I2OUP96eEj/YmE39mNjPfpkZEdHQD4Wend4Sv9gYjXdYWI6hnR2S8xcXjf+Ojwgk3N3RT5pbUD0YWY+9WJoRP9DSiz/NDwi/i41IrEkLBx9PUUw+ykvItEAAAAOKDQiLA==",
			["Draugr Elite"] = "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",
			["Leech"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqFRUMJiYqcT9KXtVve4y1VF1rhQAAFRgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAh5uqM0pGS8MzMDX/Sk5d/0NKWf8hJzP/OURT0JqvyD0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEwzNkZLNTVpamFmbk1ARoNmaXLuTE5U/2RlZ/s5ODz9DQsR/SgoMfxJUWH/QEhW+yAoNH8/Pz8MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH9yfxRtZnOhVkZQ+UYwNf9bR03/a1Rh/001PP8zMzn9MTM5/yAjJv9pZ2P/Pj5D/wgJEvwPERr/SlVn/11kbLowMDAVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACfZFUwb1xbyVBOWP9VV2D/aWh1/FJGUPsvKjb7LS06/jc7Rf8qLTX/TUtN/1lWVP8SFRv/TExK/2FeWv4hJzL7HiQv/yMqN8d4h44iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbkJYF2A3Qtc/Ky//IRoc+y0kJ/48MDj/VVtp/1Nfa/8qMT3/LzQ//09OVP9wdoP/LTE6/w0OEf9eXVz/Tk9N/woQGf4yLzH7TFNh/0hSX9kVFRUjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtWVmAZVNZ/0REVvtHRVP/MyEn/xoSGf8UFR3/MjhD/0tXZf8nKjL/V15p/2xwd/8mIST/Oz1I/z9ET/8TFRn/ISQo/zs5O/8pLDL/HiMp/ygtNMx8la4pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZ0tLG0tCRe1aUlP+a1hb/k05Rv8tJjL/Fxgh/xYXHf8XFhz/Nj5J/ztDTv9RXGr/Q0VL/zk0Nf9fWF3/NTQ9/xMYIf8xN0H/MjU8yRcXGcsaGhz4JSgt/zU8RfMaFhY5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABZQ0mjaVxd/1xMTv1HLjH/KBgb/xkXH/8cICv/Ghsl/xkaIP8aGx7/Q0tV/1FaZP8iJiz/MzQ6/y8sMP8XFxn/Ly4x/z0+SP9ESVfzNDY8hxgUFD4VDQuELjA0yyUjJtUYERFKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXlNYLllRUvFlU1b+YDs//i4cIv8bGx3/GBcZ/xYWHP8ZGiT/IScz/xocIP80Njn9PkFG/hYTEv8sMDf/HBsa/xcWGP9cW1r/Ly4x/xcZIf84PUP/VlxmrgAAAAAAAAAALCgsOR8VEmAvHx8QAAAAAAAAAAAAAAAAAAAAAAAAAABKQEdnPDU5/2VNS/xJJiv/GA8X/xQXHv8ZFxf/GRYV/xkYG/8qMDf/JCcr/zk8P/9AQ0j/EQwH/yUkJf8TEA//IB8f/yMjJv8YFxf/HBsb/iopKf1MT1b/R0dOJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxSUaZiUlT/MBga/CIWGP8VFhz/EBIb/xgbIP8XExD/FxMQ/h0ZGP8fHh35MjM2rDw+ROknKS7/LzQ9/g0PFv8mJij/IB4f/xUSFf8dHCD/JSgv/0RHT/pRUVFLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC/v78MdWtl6kk6O/8iGRz+FxAO/xcVFf8WFxv/Fxkb/xoUE/8lGRb+HhYT/zU5PvJSWGHMIyYv+hgdKP8wOkj/Fxsm/xUWHv8fIif/GBcd/x0dJP8hKjX8RUxX/1VaZGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEE2M0Y1LS38Gxcc/RoXGP4VEA//ExEO/xgSEP8lFxP/MxoX/yYVEv8WEhH/MDdE/1Vicf8bHCb/ERAY/yMoLv8gIif/Fhoj/xcWGP8cFRP+Ih0c+jE0OP88Q1DUTmKJDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKh8dihsSEf8YExD/FBEO/xkSEP8oGBX/OSAc/z0hHf8qGhf/IR8f/xobJP8XGCL/NTpA/iMlLP8TFB7/GRoe/xcUEf8YGx7+GRgb/B0WE/8yLin/Q0VK4j9LXUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZGQodFRTKHRcV/hkVEsA9Kyf2PiYj/z4nJv8/JCL/LRwZ/xkVFv83Oj7/ISUu/xEUHP8gIiT/IB8h/xYbI/8ZHSH/FxMR/R0XFf4lIB3/IiAf8jEvMYtNTVUhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxcXCxUREYATDw9CmX+ZCmJGQvFIMjP/PC4y/SseHf8YEhD+HBwj/ycpLP8jJin/Fhoj/xkbHf8bGBb/FxMU/RcWFv4ZExH/KyUj/0lIRq1ISE0uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJEgOYE1M8U05O/8lHiH/HhsZ/zY2OP8dHiH9HR4f/yIgH/8aHiL+GBse/hkSEP0xKSb/PTs7/zAtLr4kISFNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEhISA5bR0vuNScq/h0VFfYoIB1eSExR1icoKP8SEA/+IB0c/yMeHP8iHBr/JR0Z/zMtLNlfZWpdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbW1/DkA5O/wkGRj/JBoYagAAAABPU1c9NTc7wBwYF/seFxX8NzEw80dKTNFDQ0VqFRUVGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALycmoCkgHnYAAAAAAAAAAAAAAAAAAAAAS0ZLMzk1OUM4KioSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Surtling"] = "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",
			["Wraith"] = "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",
			["Kvastur"] = "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",
			["Bonemass"] = "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",
			["Wolf"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABpZFozAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu7SlIpCJfPBdVU9XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ6ZiHmPiHyUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1r5xTqaKS/3RtYu1GQTczAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYk4o5fXlv9mJhW9EzMzMKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALqzoWWemIf+gHps/11aUdgiIiIeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAo6ORKnZwaN5QTkn/SElHz0ZGRhIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvbejdaCZiP+CfG35enZr/01LRsoZGRkeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKKWhSyGhHbaVlRN/0tJSP5SUVHbS0tLGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwppeFp5+O/5GMffyKhXj7cW5l/z88OcktJy0nAAAAAAAAAAAAAAAAAAAAAAAAAACBfW0/kot732poXf9GR0P6WFdY/1JTVN9BQUEfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMC5qJaspZT/nZeJ+5aRg/+BfHD8WFJM/0lEQOZfW1PBX1pPpl5aTZVjXlKnZmBWuXJsYu95c2n/UVBK/E9RUf5WV1n/UFJU6FJSWSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA49vKn87HtP+moJD7lI1+/2tjV/9eVk79ZGBZ/2hkWf9iXlD/ZGBT/2ZhVf9eWE7/XFZN/1lUSv5TUkz/VFRU/lZVVv9eXl/tYGBmLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEuap22tHA/6GYhf1xZlf/b2RZ/25nXv9iX1f9XltP/GJeUftiXlL7WlVI/GFbT/xmXlX+ZV9U/1tXTf9ST0n8Y19c/2JgXtdRUVEWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIyFeUWlnI7/jINz/5KJe/+OhHn/bm1k/1xbU/9ZVkv/aGNX/2VjVP9hXE7/enRm/4qFe/+NjYP/iYl8/2tpXPtoZFz/WlhUrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoZOTE5+WiOi4r6D/ubGh/paShf+AhX7/amth/2BeUP9qZ1v/bmxd/3FsW/+IgnH/iIh7/4SKhP99f3j/ZWJa/GZjXP9gYFx3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADPxrMbtq2b68jArP+5tKD+p6qZ/3+Mhf91eW3/jYl6/3FvYv9/f2//oZ2H/5CKdv93em7/Y3Rw/2dsa/9cV1P8WFRR/1hWVHkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL20mnXAuZ//yMGp/dTPtv+7v6j/mqaa/7u9rP/Y0sD/hIJz/3R1Y//JybD/p6WR/4yPhv94iIX/b3V0/2JcW/tXVFP/UlBOx1VVVQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADa2rYOurGYzr+2mv/XzbP85dzD/9/Xvf/j38L/9fDV/+bhzP+Zlob/fX9p/7Gxmv+KiXn/cnNq/3R4eP9qbGz/ZGNj/lVUVf1QUFD6TExMRgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALqwmU7Gu6L70siv/eTdwP/w5cz/7uHJ/+/mx//r5Mf/yMOu/4+Nff90dWL/fX1r/3RzZv9pZ2H/b29u/29ub/9tbW3/X19f+1paWv9PT0+jAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyL2nuNTJsP/v5cv88unM/+vgx//r4Mn/8erP/+Xfxf+dl4T/ZWNU/1VWSP85OS3/NTQr/19eWv90dHP/cnJx/3Fxcf9qamr+Xl5e/1JSUvFMTEwoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMK4o23UyrP/0siw/e3jyv/u5cn/4Na8/+DWwv/t5c7/4dvE/3NtXv9PS0H/Q0I8/yQjHv8dGxf/T0xL/3V1df9xcXH/cHBw/3Fxcf9hYWH9WVlZ/1BQUKsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1r5Mtwbig7s3DrP7SyLD95NnA/+Tbv//h1r//39PC/+rjzf/e18L/bWhZ/z87NP8wLyz/IyEh/yQhIP9PTE3/dnd0/3FxcP9wcHD/cHBw/2NjY/5YWFj8VFRU/k1NTVwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmReyPDuqLfzcWr/tLKsv3h2cD/2tK5/97Vv//Uy7n/wrqo/9jRwf95dWn/SEU9/y4qKv8mJCT/MC4u/1dUVv9zcXD/cXFv/3Jzcf9xcXD/aGhn/lpaWP1XV1X6Uk9PXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARUUuC7qymsjUzbP+1c63/N7Zwf/NyK//z8mv/8e/qf9+dGT/pZ2O/42JfP9QTUP/R0ND/zw5O/9BQED/X11d/1tXWf9zc3H/c3Rx/3Fxb/9sbWr+YWJf/1VVUutMTEYoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACJf3Ayl497+szEr//a0r791tG7/9TQt//KxKv/xr6n/6efi/+KhHP/gn9v/1xZTP9OSkj/RUJE/01LS/9KR0j/YV9g/3d3df9zc3H/cXFv/25ubP5mZ2X9W1tY/0tLSFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHxxZy+Cemm/oJaF9aqhj/64sZ771tC7/MW/q/6/uKT/xLys/6KdkP99eW3/b21j/2FcXP9MSUv/ODc3/0lHSP99env/d3Z0/3V2c/1yc3D7aWpn/l9fXfxWVlLUTkpHSwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6b2CJj4Z2/6ukk//SzLr/urSk/aqklvyfmY/+j4iC/396dv90cW//XFla/05LTP9YVlb/d3R1/3t5ev16enj7ent4/25vbP9iY2D/VVVSwzg4OBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH9/XxCLhXZWl4+EhbSuoce0r6X/l5KM/4J9ev96dnX9eXd3+3h2d/11cnP+eHZ2/Ht5evx9fHz/gH9//39/fv90dHHeYWJfmFRWUWdQUFAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPyo/DI+LiEmDfn6bfnl664B8ff+Bfn//fnt8/3t5ev99fHz/fHx8/3l6ev17e3u8c3NzY2BgYB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDe4Mdfnx8b319fbF8fHvde3t76nh4eMR5eXmKeHh4OQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHd3dx5/f38qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Drake"] = "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",
			["Fenring"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZlYk/sKybeODbyjry59J359zFFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmXmYjnZqOk6KdkP6moZL/u7Sj9O/lz+Pz7tEtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0ODRESEhCnlZSSeRmYVf/gHxy/315cPpoZFr/dnJnjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwVNzg4mVRRSv9kYVb/W1hO/2RgVvxmZF7+UU9G/UlGP/4+PzvpREREKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGx4mQkdHSM9kYln/V1NL/lBPTfxoZ2P9aGZg/0VDPf87OTP8NzYy/zs6Na8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEtLQlRXWFb1TEtL/2ViV/xfYF7/YmJh/2ppY/9ISET/LS0q/i8vLf4pKyjzNTU1MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnZ14bTk1NqFFRUP5fXFb8WllW/0lJSP9hX1r/UVBL/z88Nv81NTX7MTEx/zU3MpMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFpSUh83NzRORUM9X2dlXtZHR0b/ODo5/U1NS/8yMC7/NzQu/lJPSf5CQT7/Kior/DMzMf8xMS/hKyszIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIuDeyFkYl9oQ0NDnkhHQ+teXFX/WldS/0JBPv4eISb/Kysr/zs6N/4zMjH+NDM0/yQlJ/4cHB7/IyQl7CUoL0sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcGxoPU1LSZhLSEPWU09I+1BORv01NDT+JCYo/zo7PP9CQ0L8OTo6/zY1Nf86Ojn0Nzc2/TAzNt0bJDBVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD09OlM9Oji6Skc/+U9LQ/9MSUL+QT86/zg2Mv85NzL+PTw5/lpaVv8pLDHELS0tVTQ3Or0wNT3YKiw4WwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEVBOkZGRT+1RkM89E1KQv9MSUH/TktC/k9MRf80NDH/R0Q8/jo5Nv0rLjD4NDk9twAACB0AAAAANDg9eTM0OowAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NDCIOTgyrENBOo9FQTvjSUU+/EVEPf40NDH+ODY1/1BPS/5MTEf+QUFC/ycoK9EAAAARAAAAAAAAAAAzOzseQ0NDEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASEhIbKSkopCkpJ4A7ODJWQ0E600E/OvxBPzn8OTg0+yIkJv8VGB7+OTo7/mJhWfZJSkreOjo4lQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERETsSEhI2Nzcwczw5NeU9OzPpPz436j47Nsg5ODT0KCkp4h4gJP0dICT/R0dJtT09PacqKio8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMTDRoYGpIfHyDRMTEstjg3M9M7OTV4PDo15DY4NHkgIiSNHiAj/RsdI+seIShMTkxJcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANEBRvDxIVtRwcH6EkJCS9Li4qSDU0MMg1MjGcAAAAAB0fIaIfIST/HiAkhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBUmJiSaMTEupSMnI0EtLCvIKCgokAAAAAA8PDUmODc28y4uL8EkJCQOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACg4VSBASFH8iHR08LSwpxSAjI14AAAAAZ2NXQFJPSc1FRELXJycnGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADx4RAAAAAA4QEn0VFRU8ABAYHzk3N6plYlqjTEpHkzAwNioAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGRkKAAAAAAAAAAAXFxcWAAkJHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Stone Golem"] = "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",
			["Ulv"] = "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",
			["Cultist"] = "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",
			["Moder"] = "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",
			["Deathsquito"] = "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",
			["Fuling"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5/B6NszUbn+3vmN2qK1cLwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIyFsOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzNVsPcDEZJ7I0GrwyNBq/6SrWP9xekDpWGE2lWhyPjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABzc0ULAAAAAAAAAAAAAAAAAAAAAMHKaTqaolWEm6NUiKCnVpGyuFzBu8Jh3K+2Xcypr1q5r7RepMLIaLLGy2n8vsRl/6arWP+aoFL7fIJD+3N5Pv90e0D/WmI29WVrOq1tdD6nfIREuYyTTMyIkErbeIBBu3B5PoplbTyKZm06gm55Qi4AAAAAAAAAAAAAAAAAAAAAAAAAAGl2Pil5f0bManA//1JXMv9YXzT/Vlwx/3J3QP+an1T/rrRe/42US/+Ol078nqRT/pGXTf+Jj0n/e4ND/WNrOPxOVS3/T1Yw/0pQLP9CSSj/QUgo/0tSLv9GTC3/Vl01/1pgNcNVXDEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFVhMBV1d0LIYGM6/0BBKvpERyz+S00w/XF0Q/yAhkf9VVIv/2FTK/9zeD7/gYhF/2VtOf9WWC7/UEQj/0RGJ/5ITiz9Njsk/DE0IP0yNSL+LzQh+jtAJf9JTiy5W1s2DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI+PRyCGikvOfoBJ/2pqQftiYT3/XF08/4yPT/+goVP/dGs5/3R2Qv+jqlf/WmM0/0xLKf9vaDf/bXM7/0RJKv8rLh//LzIg/y80H/o+Qyb/UFYwwn9/RhIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHV1PiWRlU/JmJlV/39/SvxrbEP9gIJL/5adT/+Pl07/hIdI/36ERP9LUiz/W2Ez/2hyPP9TXDD/OT0l/y8xH/04OyL8SVAs/1RcMrx0dD8YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHl5PBWWmlGtpalZ/5aaVP+TllP+ipBK/4GHRf+Hi0f/X2M0/1FVLf9RVy3/SFAp/0pRK/9ARCj+REoo/09VLv9WXDGlZmZEDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACfpVV4oqhW3LC1Xv+mrFf+j5ZN/5mdUf+BhUT/en5B/1FYLv9IUCn/UFcu/lFYMP9RWS7UVFsxbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEhEsbkJRQqKasWf+mq1f9pKlX/46SSv+Gi0f/VFsv/05WLf1VWzL/TlUxm1BdNRMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYTwqiI1N4qmvWv6Zn1D9dX0//3J7Pf9TXC/9U1ow/0hOL9czMysjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB1e0RdkpZQ/4F6RvxtYTz+b2I8/lpWMvxKUC38REctTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8/KgxrbT7DeHhD/2NiNv1XVzH9TU8t/zxBKa4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRkQStaXjXTSk4q/z5DJf88QSXDPT0rHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMzGQpISy1VPUAnRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Fuling Shaman"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE46Og2Ma1BmAAAAAIxmTBSee15nAAAAAAAAAAAAAAAAAAAAAKF7XWW/lGoYAAAAAKJ/X26Pb08QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/alUMX0c5XWdQPPiZclZQVUEyQotrUPiqimowAAAAAAAAAACFZ04qnnxb9JV0V0aNblJKjm1Q9Z15WmPIkW0OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAkMBVWRDnGSzsv6G5VQNhmUD1faFI+65Z3WoQAAAAAAAAAAI9xWHyFalLsemJKYIZmTdV0W0XllnVVxHlYTRcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAW0tDQAAAAAAAAAAAAAAAADUuK45RQDP4Tzwu/19JN95cRznzgWVLzgAAAAAAAAAAhWhOyXxlT/RtVkDgalE9/4FkTfZ1XEWPAAAAAAAAAAAAAAAAmnZWR6p/VQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEPzxZQzcyol8/KhgAAAAAHxwfUUE0K/9GNSn+Tjot/1xHOf9jSzzec1FFFkwzJhRtVkLdcFpH/19HOf9iSzn9d1xF/1tHO1YAAAAAlnNRFn1hSZ1/ZU5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxLzGAOjEt1083JyAAAAAAOCwn4EEwJv5AMCb6Uj8z/lxHOPJoTkEnWkM8ImVQQe9hTT7/VUEz+mVNOv5mTT3lf0xMCndVOx5yWELTZ1JCggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJyqcKSIh3yofFRgxKCRxPS8n/zgsJPxENiv+WEc6/mNPR0BjUkU7YE5A/FVFNf5SQzP8ZE09/2JKNnVNNywXWkQ03FpHOp4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjISOYJB4e4CMcGVAxKSTYOS0m/jgsIfpYSDj/XE09Y19PP2BgTz7/TD0s+ldGOP1aRznbTDsuTVA+Mt1UPjSaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjIyeHIB0e2yYgHNQ2LSTtMCggoz41KvFCPC9QPzkyTEw+MfBKPC+dWUk46U9AMdVKPC/bSj01iQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiIiRvHhsb0iojHstWQDM7aE44sOGcZKXkoWakdGRKsWZZQzlQQTDMRDgs0EQ5MG8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUGxslKSgomYBWOOW6ckL20IFP/9OFUf/LhE/3un1M42JMN5wfJh8oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJiY1UzQk9phXMf+7cUP7zoBR+857Sf+9bDr3qmM4NgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8uLkxXOCj9jlMu/a9nO/7HeUj+x3dF/s11QP3HeD5OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTE5H1k6KN+ITSf+oFsv/LFlNPy6ajX+tWo83qFmTB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATkZBXm5LNf+NUSn/nlou/6ZpQv+AYE1fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXVJMXW5PPtl3VkLbcV5UYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Growth"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtqORDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0b+RHOzjwK/Px6xgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOrdpyb37sDT+fDNkQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA///hTsjEnO0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4dWqgtK8mxcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///8svbyV+UZEMoMAAAAAAAAAAAAAAAAAAAAALyoqMEE4OHk4MzC8My4rwEI8OH5LRkI2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOTZrGDm2a+6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///w3s462vk4pr/1NNQpU0MDA/ODYwgzUwLcwoJCP7MSst/zIuMP8rJyf/Lysq/ywpKPwyLi7QRUJCh0xFPkk5Li4WAAAAAJd3RyDNwJiL39Wu8sC6lEoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMwaCEbGFV/y4pKP0qKir/JSUn/xARFf8WFh38HBsj/BYaG/wUGRj8Gx4e/ygnKf8rJyn/Kick/05HONC+sY2d5tqt7djPqtm5tJg+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA///YLrqqlY5IQTf8IyQk/BEVHvoUGCD9Exgg/xkcI/8PEhn/ERYb/w0TF/8NERX/EhQY/RYWG/sVFRb7V1NE/9LIqezZ066CAAAACwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/zr4Hn1ab7joFt/ygpHP4MEgr/ExYa/x8iJv8nKiz/FRcY/w4QE/8XGyD/GBsh/xgbIf8WGh//GRoh/xgZGvsqKSP9NDQsfgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//q8Z72yg+VlWEXxkI5x/7i6lv+3s5j/pqKP/4uKf/84NzX/CgsO/xMWHP8XGh//Fxog/xkdIv8dICX/Gx0f/CorJ/9JR0CuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxL2gI6WbgdP//+L/k5Z5/V5kV/8sLyj/FxgU/xgZGv8XFRr/ERMY/w0QFv8MEBX/FRge/xYZH/8TGBv+KSwr/0hHQd5cUUUWnJx1DX9mTAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARWlRA725sWv8LEAv+CBQa/wwVHf8UHCL/Fhwi/w8UG/8NEhb/Cw8T/xEVGv8WGR//DREW/xEZHf8ZIB//LC0p/3JqYd7SxqXP18ubwOHZrazv6ruY8+u9hPXvwnHZ0qwiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFZKQT41MSn/Gxwd/xMYHf8WHCH/Fx0j/xYdJv8NFR7/DBQe/wkOFv8OERf/DhIY/w0QFv8SFxn/FBwf/xghIv4sLin/ZV5Vcf/40yn/9MEy///NLv//2C7//9Ey+vXKNeHhtBHayLYOdXBrMlVaVTNTWFM0TExMMkQ/PzRBQTsrRkZBbT09N/8wMzD/HSIh/xYaHP8RFBr/CQ8X/w8UHf8SFiH/DA4Z/wsOF/8IDBP/BwsR/w4SFv8RFRb/FhgW/jU2Mf9GQTliAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN/ZwCmTi32Ybmpism1sY8hzbWXadGxg5H93a+B+fHDjMTEp/yIlH/8dIR//Fxse/xAUGv8SFh3/Fxoi/xATHv8TFiP/CQwX/w0QF/8OEhf/Fxkc/0dHPv83Ni7/KSYn+zItLTMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKqUlAy7u5kP4dK0EaqhkB4yMCbjIyYg/yAkJP4hJSj/HSEn/xkdJf8SFB7/Fxok/xATH/8LDhn/ExYd/xgbIf8JCgz/iop8/oaEcv83Mib5KSkTQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY2LaopLCb/ICUk/C4yNP84O0H/GBsi/xYYIv8UFyL/EhQh/xATHv8NERf/EBMZ/ywuMf9naWL/dHRg/725l/6wrIftZ2RQrB4PHhEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsZGQhRklCvyMmIv8YGxr9LzM2/0NGTP8UGB//Fhki/w8SHf8VGCT/Exch/wsPFv8ECA3/O0BC/z9GRvwkJyD/XVhGqv//90Gel3/MZl5SQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZf5kKZWNdgGFgXO5YV1X/Liwp+x0cG/0qLDD/JCYs/xsdJP8jJi//GBwm/xUXIP8cHib/GBoh/xQWHf8OEBX/DhIV+C8wL/0uLiptAAAAAMq9ojqsnYciAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH17dJBycGr/ZGBdmVpVUmNKQz//PDY2/y4sMP8dHCL9LzE2/DEzOv4bHib/Fhkh/xkbIf4gHyX8JSMn/CQiJf9STUf/dm9h/0I+M4IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACRhWZBb2tb+mdnYYAAAAAAAAAAAEQ8N3c+NjTIMzAw+iknKP8tLTD/KSou/xMXHPsbHyf7ExYc/xsZHf8yLC3/OzQx/F1TQcf88s/HtamL/1dRQHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKuce4R2bleyAAAAAAAAAAAAAAAAAAAAAAAAAABNSEguR0VDeTg3N7kxMTPoKy4w/yktMP8uLzHrMC4tvkI8OH5EOjU0AAAAAAAAAAD//859mZR3/01LQF8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8eO+N7KoirNiYk4NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExGRig8PD5mOTk5a0VFRSwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACqrJR4YGFXpwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAz8aibKylfyIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHN3aEJsbGF2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAysWrMZyYiTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Lox"] = "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",
			["Yagluth"] = "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",
			["Hare"] = "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",
			["Seeker"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAS0UwVFhROUsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARUU5LDY2J1VPSzdKVE055kxAK7pbTS9WAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUkUtPjcxJZs/OjDiPz8wZAAAAABFOi9xV0cz/19OMf9XTS3PUUowbldHJyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABrWDoaV083YEtDK71COyf9Pzgq/zg1KosAAAAAAAAAAEMuGiZpWD3valw9/lNJMf9RSDX/VEcw4GlXN49zWjEfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/aUMiYU44i0k8LNo/OCn/QDcu/0tFM/9GQCvsNDQaHQAAAAAAAAAAAAAAAGZSOtJgUTj/XE04/E9FNPtKPiz/YE0y/3liRNxcTztNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfm1UW2ZYNuJHPSb/PDYm/z05LvtEPDT7R0Eu/0pELcQAAAAAAAAAAAAAAAAAAAAAYkw9qWdSQf9eSzP8Szwq/1NGNf1ZRy/7YEMn/4NlPPthTSeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACnZaQpltUTH/RjgZ/0E+JPs4OSX9Ojcn/0Y+L/tQRzj/ST4viwAAAAAAAAAAAAAAAAAAAABbSC97alU3/3ZiPvtWRC7/Vko0/2pZMv+PXi391ZFP/L2LU/9qTjR1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0WkimoXJN/4hXKftaPBr9UEMr/z08Lv9IQTb/V0Uz/VI/L/5LPS9bAAAAAAAAAAAAAAAAAAAAAHpjQ3lvWTn/aFU4+2dTN/9gTy7/alMn/7mJTf/lr3b+rYVX+3NaPfpSPS5XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXVBEkWZWQP+Udk36qIRV/m5VMP9PQCX/RkEv/0hDM/5XSTP/UkIs9FFIMDUAAAAAAAAAAAAAAABSSikfbmA+32xeQP5ZSzX+Z1c4/2RVLP9zXjT/rYla/5NwQv+BZkL9cF9E/2RUO/FQPiM5AAAAAAAAAAAAAAAAAAAAAHJgUXRjW0f/U083+l5RKv55ZTr/dGA//1NDKv9SSjb/TEc3/0g/LvxZTjj9XE07eQAAAAAAAAAAAAAAAFFNNHBkXz//Yls9/VhQN/9dVjf/b2dC/2pdOf+OdFb/knBE/6KGW/9oWj37dGVB/2dVMG8AAAAAAAAAAAAAAAAAAAAAb19HylhUOv5kYED8i4Bd/2tYN/9wWkH/WUc1/1dPP/9KQjb/TEA0/VZLP/9MQzfzRDszHgAAAAAAAAAAT08/EF1TO4BpXUH2bGJG/F1VPv5lWkb/WUsx/21YO/96Yjz/fWZC/3FfQvxnUjX+fGFBfQAAAAAAAAAAAAAAAOWyZgp2X0HRU0s4/1pUO/1jVj//bl1H/1dHNP9USDb/XldE/1dNO/5WRzn+Vko99U1FN4s1QygTAAAAAAAAAAAAAAAAAAAAAHNmSoJmXz//U0s1/FZKOf90Z0//Y1E0/2FNKv91YEP/alVE+2VTP/1mUTedAAAAAAAAAAAAAAAAoX9JJnpkQ+VYTD3/Y1lJ/l1OPP9UQjL/XU8+/01DMP9DPSf+VEs4/mhaSfthVT9UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFRUADFlVMtFoXEH/dmVR/XVlTf9uXUH/g3NS/3RiSP9eTTv9ZFc4/3pqSI0AAAAAAAAAAAAAAACnj0opjHNG8WJPNf9dU0L+aFlJ/1dHNf9gUkD/Z11J/1lSPfxYTjn/U0UxjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAb2RCd3BfP/9jTTf7aldA/4FyV/+Ogmb/fnJX/XBlRf+If1Gy4dKWEQAAAAAAAAAAAAAAAAAAAADHpmpll3tT92NZQv6HeWj+gnBf/2daR/9WTDn9XFZB/l1VPedsXD0hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABuWzQ1d2BC8npjSv96Zk3+a11D/2lfRP9lXD/+b2dC/3x5SlIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUdlTNbmFK/2VZR/xoWEb/ZlhF/2FYQ/xcVT7/V083oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL+nhkykk3P5eW5U+nxuWv18b1r/cGVI/29jQP1zZ0L/k4tnwCwbBS4AAAAAAAAAAAAAAAAAAAAAjHdca4l1V/NkWkX+aF1K/29iUP93bVz/cmxX+oJ3XvyXim6RAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhXVac4R6Xf9zbVf/b2RV/2NWRP9+cFv8jXtg+52Ob/ySiGv/fnBN74d5VMhRSChxbWdKnnxxXdyJd2T9k4Zt/4F7ZfyLgGz8cGRS/W5oVv9zbVn/i4Bl/5eJcMcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNQjcXWlA+UmdgSo9nXUnUdmpW/IV1Zf96alj/h3xf/397W/+WjGz/mY5w/3BrTP9qY0X/k4hz/4FxYP+AdFv/eXBX/4N5Zf+FfGn/bGZS+WplUslyaVWKcGJMRgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4aVY1jX5rd3dpUqCFel6oko1vqY2DZrF/dljqh4Fi+XRqTPh2aljKjIN2rIB4YbJsYkuyfnhkm3ZxXmeIfG8pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiLZruekW7/jYFh+WZdRzkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgTyItnodd1bahf4atmXPZdmZGfwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJyJTg2NcUYkAAAAAMaxeCSgjWM2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Seeker Soldier"] = "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",
			["Tick"] = "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",
			["Gjall"] = "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",
			["Dvergr Rogue"] = "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",
			["The Queen"] = "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",
			["Bonemaw"] = "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",
			["Fallen Valkyrie"] = "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",
			["Charred Warlock"] = "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",
			["Charred Warrior"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbbRxibHNLaXV6aHB+goN0foObVlpgq0RLT5RFTFB1Mzg7Wjk5RRYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABZZmY5YW1y4Gt2fP90foX/fYeN/3N+g/9XX2T/TVRZ/0lPVP87Q0j/PEFHzj5ESyUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAV2BgOltlaulodHr/b3l+/XN+gv15g4n8c3yD+09ZXfxHT1P7T1lc/EJKTvw/SE3/P0ZJ3D9FRTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFJcX1NdaWzrbHl8/3F7gPx4goj/d4GG/4OOk/94g4j/WmZp/09aXf5RXWD/SVRX/0RPU/pFTVD/Mjc3zyIiIg8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3N0IXX2lw6nqFi/95hIj7f4iO/n+KkP9/io//h5KX/3B6f/9fZmr/X2Zr/1ReYv9OWl3/SFVX/0pVV/o6RET/KzQ0cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEtVWndueX7/g42S+neBhv57hIr+eoOJ/36Jjv+FkJX/dH2D/1teZP5lam/+XGNn/1ZgZP9VYGP/UF1f/jxJTf4rMzflMTo6GgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8S0sRS1hbz257ff59i437dICD/nB6gP5wen/+e4WK/4eSmP+Jk5j/Y2pu/mNqbv5qcXb+Y2tv/mRucf5ZZmr/PUlO/CkxOP8tMjmSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9MTF1IUlP/ZXBw+3WAgf1we33/bHZ8/2hyeP9veX7/foiN/omUmf9pc3b+ZG1x/mx0eP5xd3z+ZGtw/1FZXf89RUn8Ji0x/iImKtw1NT8YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARU5McU5XVP5sdHL6b3h2/2hwcv9sd3z/anV7/3J8g/98hoz+go+T/2FtcP9ha2//bXV4/mZscf5WW2D/RkdK/khJSfs3ODn/KSkqxlxcXAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQUFBZV1JT/2hgXfxgV1T/XVdW/2FgZv9obXT+cHuD/nyJj/+Bj5H/Ul5d/1NeYP9YX2P/Tk5S/1BJS/9JOj3/Piwv/DYrKv8tKCfETGZmCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRHT0deRUr8SCgm/kghHv5HJCL/VTs+/1ZOVv9qcnn+fo2S/4OOkf9TXl3/RExP/zw8Qv8/MDT/TC4t/0YZHv9CFxz9Nxoa/zEjI9csLCwXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjjxAO18vNfVVIir/by4y/nExMP9WJSL/Qysu/3Jvdv+FjZT/bXZ+/1tkbf9GSlT/QTdB/0UhKf9YHh//dCor/2UjJvxXKS//RiYs0hwcHBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvSkUwVjUz8GMtMP+cRUf+tVVW/3MuLv9nSkz/goWJ/3aDif9UX2f/Ul1n/0hKVv9OP0z/ZDpE/2cjJv+rUlP/fiwx/GgyPP9RKzLVHg8PEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEtgYCVSQD/lZzY3/40/Pf6OPDn/fEdK/4dzd/+Ei4//Znd7/zlFS/8vOT7+UVZe/09FTv9xVFr/cD0+/2wgJf9zLDT9aDlB/1kzOY8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARmBgHVZIT91VMjn/Uygp/WtKSP9+b3H/fHZ+/3x+h/9qcnj/HCQn/xogIP5RVVj/UVFY/1hPU/90XV7/aUFE/1YuMv5JLzL/NyEhXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYWFgaV1FY22hgZv9tZmj9b2pu/3Jydf95en7/jZCX/09VWf8IDhH/FRgc/zU3PP9QUVf/UU1U/1ROVP9nWFj/XE9N/Dk4O/8uLi+QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFZcXCxdYmbqjZOY/250ef5WXGD/eH6A/4aMj/+HjY//Jy0w/x0kJf80OT3/MzY8/0lKUf9TU1r/RkZN/1BQVP9panD9W2Fo/i0wNN41Li4mAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARU5XVVpkaf9SWl/9Iywx/j9JTf19hYj/kpue/3N8fv8OFBf/Rk1S/1pgZf8qLTT/QkZN/lhbYf80Nj3/LzQ7/0tSWv5MVV7/KC41/zc5PFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkLTYcJjE5yRwoL/4fLDH+NkJH/2l2ef+QnaH/bXp8/z5ISv9ueXz/Z291/zxDSv9FTVP/TlVc/iYrM/4dJCv9Ji81/yk0Oe8fKjJ5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOUJMhkVPVvcsNjzWTVte/n2KkP15h4r+c4GC/oGNj/9daG3+Ul1j/lNdY/9CSlD+Iisw/BkjLP4cIyzfKCg1JgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABVXmtOUFpj1B8oLng8SVD/Z3V5+mRzd/5hcHP+eIaK/0hUWv47R0z+RFBU/jdDSP4bKC3+GCMs/x8mL8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFJdZURKVF3iNEFIZkJPV/hGVVr9NEJI/y08Qv07Sk7+IzA0/xYlKf4gMDT/JTQ5/x4rMOMgKTDlJCsztgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANUVPMFVhafdmcXm5RlNasUNSVv8+TlT7OklO/0JRVf8xPUP/JzU6/yg5PfYbKi74IjE0nDE5Qd0mLjalAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGhodR1Fa4nJ9hP9hcHfYW2pxul5udXpgb3bOXGpw0k1ZYcI8SlG4PUpRjCUxN6ktNz/gKDE5/x0kLZEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjLTaeYGx0/258g/9qeoHRYHJ3y2FyeNhneXzpTFhf4zhCTM5PWmXeTFdf4DQ+R/8eJy//GyErUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIEB9ASlHeZHN5/nGDiP91h4z/aXyA/2d2ef9cZW3/Vl9q/2Rvev9JVF7/Iyw0/yoxOLkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9LTkRXZWn2eouP+ZOjpvuJmZv9gI6T/XB3fv5XXWj9TFRi+yozP/ojKzH2Nj4+PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE1YX411goj/hJCW/Y+bn/yapqr8anB2/EdNWfwwOEP9JCs2/zE3PJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk5iDVNbYbpeZm3+dH2D/5GZnP9iaGv/Nj1D/zA2QP4oLDbOLDc3FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQtMjg3P0Z4UFdZtEpRUcMrMzSCLTE5PgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Charred Marksman"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2ZGQrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExDQq2AaW64jWxxNgAAAABaWlIfXEZIW19GSoZwUVWzhFpilgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFRkhg1lGS/+IYmP8gWBg13xPTvh/ODr/aDE2/11DSP9pU1fEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHyhRGx8o/l5FSdh2PTzkbjEy0HsxM+hdKi/8SDI5/0UvNmcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaHye5KzA36Uc/Q3kAAAAAhDk5R1w1Of0+O0OXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALTY/dUZIUOA0Nz/MKioxuRIVHV85LTScOzE3/1JUXL91en8yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZMwosLjvKRklR/zYzNpsgIyeuFx0keCgqL7YeIifgPkBI/1tfaYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADI0Qbw+QUbrNTE1QxMbI0EAAAAAJSUvGxoeJkMqKzP/Q0ROiQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJS01nkFHT+tmcnIUAAAAAAAAAAAAAAAAAAAAACYmL/YxMTx7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXICh3Mzc+52lyex0AAAAAAAAAAAAAAAAAAAAALS422zc3QG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQ6Ok5ASE/daXuDHQAAAAAAAAAAAAAAAAAAAAA1PEG7SlNVXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARElJLUNLU9hVXWYeAAAAAAAAAAAAAAAAAAAAACkvOaU5QEVqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJiYUOUFH2khYWDEAAAAAAAAAAAAAAAAAAAAANTg9tUBFSm4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3PkPjSlhYXAAAAAAAAAAAAAAAAAAAAAA5PULMSVBVaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQ2P/JGSlJ+AAAAAAAAAAAAAAAAAAAAADM8QuNDTk5iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANThA6D0/RrwAAAAAAAAAAAAAAAAiJjJCKTM4/UZPUYYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsWGy4mLjT4QUhL+1BXVyMAAAAAAAAAAC0xOnEnMTL/Mzw8igAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCApHyQuNNY0PUDcampqDAAAAAAAAAAAER0jKzQ9Pv9GTEx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADw8QKjQ78UNRVbUAAAAAAAAAAAAAAAAODg4SLS838T9DR3wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4jKDMjLDLeO0VMawAAAAAAAAAAAAAAAAAAAAAhIyu8FhgfaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAR0tLPTE6PZAuNTlMAAAAAAAAAAAAAAAAAAAAACUmLKsaGiVgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABWUlI+Jy80pis2OkYAAAAAAAAAAAAAAAAAAAAANz4/lDk/QlgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFVVVTYxOD/FRE9SSgAAAAAAAAAAAAAAAAAAAAA4QUWMO0RHVgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIicxNDY9RcZTWl1PAAAAAAAAAAAAAAAAAAAAACoyOZw1PENIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuLjksIisx3zA4QV4AAAAAAAAAAAAAAAAiMzMPMDxEzUFRWEIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0tNCImLzX/N0BFcgAAAAAAAAAAAAAAABgdJV8wPEX8VmhxWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGxskHCw1Pf9CT1aRAAAAAAAAAAAAAAAAFhwkfi8zPP9TYGjgWmt3LQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiJS9RQExU/1JgaK4AAAAAAAAAAAAAAAARIiIPIiIqnEFLVP9WZWvOS1JZJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsmLUk7R0/9U2Ns4VVmZg8AAAAAAAAAAAAAAAAAAAASKC82yFtnbv9QW2F4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFB4jMjE8RP1QYGf+RlVZbAAAAAAAAAAAAAAAAAAAAAAiJzE0U11jn1ZgZTUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARGhodLDk82klaW/9PWmDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaKi8wPkpOe1hibEsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Volture"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQUFGUyMjKdFxcXCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATExOTHx8f/ycnKf8TExatFxcXCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBAQnxUVFv8yMzT8FRUZ+hIRF/8VFBm8FBQeGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHh4eERAUFrcZGx3/LS0w+zI2OP4ZGCD+FBMb+xISGf8UFBrTFRUaMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMdHRoSEhXBGhsd/zExM/s5OTz/Hx4h/iEgJf8bGx//FhUa+hQTGP8UEhblFxMXQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAT0RPLVZFTlh4YmJyjW5nUY92bykAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPDxYiEhEWzh8eH/8vLi76Ozs7/i4uL/4hHx/+IyQk/xgYGP4YGBj+Gxsc+iQkJf8wLzDyNDExUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExDRXVSREvtalVc/6CAfv+wjIH+yaWX6o5wZV0AAAAAAAAAAAAAAAA3N0IXDRISNw8PFdkdHR//MC0s+0E+Pf4qKif+IyMh/kA9PP8uKin/LCko/jUzMP4oJyT/Pz88/UZFQv89Ozv+KScnuRgYGFQXFxcWREREDwAAAABEOjoaPTUx405BRP9zXGH6sIyE+s6hkPnltKP/roh9mwAAAA89Mz0ZGRchgRQRGcwVFBnuHRwf/yopKvxCP0D/PTk5/yAgHv8iIiD/Pzw7/jkwMP9RSUr/Qz08/yAcGv8yMCz/QkE9/kZEQf82NjX/HyEg/xobHdIVGBjGExoXdU9JPi1HQjnuSUA9/XNeYf7DnZL/8L6s/uu5p/2si37qFBANuBAQFtkXFBz+Gxge/yEeIv8tKiz9Pz4+/z4+P/8pJib/NTQ0/y4sLf8yLzD/VU5L/lROTf86NTX/IR0f/hsaGv4wLy7/REJB/zk6OvwdHyH9GRse/xEXGP8QFxH9Kikg5WBdS/xGQzb/WEdF/5lxaf/uv6v/1KuQ/5d5Zv0YDQv/FRIY/yEeI/4vLDD9LSst/jk4OP9JSEf/NTY2/yEhIf8xMTH/Ojo6/zU1Nf5ZVFH/SURD/zo3Of8eHCD+FBUZ/h4cHf4wLi/+Jycp/xQWGv4UFhv8DxIZ+xcaHf89NjH/MCce/z01L/86Kif/cEk8/8OTfP/PpIn/hmxX/iQcF/0gHSD8LSgs/jYyNf45NTb+TUpJ/y8tK/8uLSz+LCws/ycnJ/48PDz/ODg4/ldUUP5KR0f/PDo+/yEgJv4ZGSL+Ghke/xgWGP8UExf+ERIZ/hITGv4QEx7/FxYh/y0dHP5RPDf/RDUx/zEcFf+AUDn/uYRo/62Da/9uVkX/KScf/y0sLP81LzL/QDo8/0lEQ/5SUE3+Pz48/h8dG/40NDT+Jycn/jExMf5FRkb+XFpX/lFPUP87Oj3/HB0j/hYZIv4bGyH/GRcb/xISF/4REhn+EBEZ/hERGv4UEBb/TTg3/3phWP9MNy3/QSgY/697Uf+7h2L/akcw/2JTRf8pKiX/NDMz/zgzM/8+Ojn/TklH/l1aVv9UU03/ODY0/jExMf43Nzf+JiUm/TExMP9fXVr/UE1N/1NPUf8nJSn/Fxoe/xwcIf4bGh/+ExMY/xQSF/8UExj/DAsQ/ygiJf95bGX/oY+E/2xUS/9RNBz/v59Z/7CPW/+af2j/mot+/0E8O/83NDT/Pjo1/zw4Nf9IRED/WFRP/2FeWf9WVFL+NjU3/jYzN/8wLi7/JCIe/mFeWf9kX1v+enRx/lxYWP8qLCz/HB0f/hsaH/4WFRr/FBMY/xcXG/8SERT/JiIh/3NpXf+Zi3//gm5l/19DK//Bo2H/pIdW/6mRfP9+cmT/Pzw6/zg2Nf9APDj/SUVC/1lVUf9JRUH/XVlV/2FfXP5IRkf/KSYo3TY0M+kuLSj/aWVc/21mXv9/eXL/cm1p/0JDQP8mJij/Ghkd/xkYHP8TEhf+GRgd/xUVFf8lIRz+enFk/3tvZP9lVk7/blZD/7OSZP+TdFH/m4Zz/3lxZP9BQj//Pjw7/khDQP5STUv8dG9s/V9aWP5KRkP+VFJQ/11aWv9EQkLrQUA+q0JAP/qJhHr/fHRr/3tybf5hW1j/WllV/05OTv8lJSb+IiEk/xkYGv8XFxn+FBMS/0lEPP+MhXX/d29j/01DO/9mVEb/iG5R/4NqUf+fjHv/hn1x/1JQS/9PS0n/T0lG/WBaV/+CfHn/bGdn/0pHRv4/Ojr+Xl1Z/VNRTv87OTebX1tdiJKLhf2Fe3X/enBt/1ZQTvhmY2H/b29u/DY2Nv8uLi6PISEhtRgYGP8ZFhT5UExC/6Sdjv9+eW7/R0E5/4N3bf+PgW3/e2xX/5eIeP+Ognf/UEhD/U5HRvxJQkD/W1RSs4qCf958d3P/XVhY/kE8Pv4+PDf+WVhT+1JQUOgwLTBJhXh4/4h+ff9ZUlG/eHNu7YF9dv9cW1n8MTEz8TQ0NCIeJR4iGhsZ5xoYFv9FPjz6fHVu/lFKQ/93cWn+jIR5/5+Vhf+FfnD/V1BF/2lgWP1KRD3/Qj05/zgzMMMuLi4Li4F9lo6Cff9oX138RkND/zw8OPw7Ozj/R0ZF/y8rLXxvZmj9V01Pg2FcWHGVkIj7eXNp+1NPT/8oKC6JAAAAAAAAAAAvLys7GhcXwiYfI/8zKy3/QTs4/HBrY/90cGX/jIR5/3dzbv88OTf8TUdD/0dEQPBBPz2BSEhIDgAAAAB7cW9lk4aD/3Vtaf5LSUfeOTw5UCcqKo8qKSzWLScthjk3PXgSCRIckouIs5mTjf9sZ2L/REFDnCcnOg0AAAAAAAAAAAAAAABMTEwKFxMXdiUfJeg/Oj3/SERC+0pHRPtRTEn8RD1A+kxESf9IRES/Nzc8MwAAAAAAAAAAAAAAAG9fXxCFgH7Ng399/2JiYMQAAAAAAAAAACwhNxcpKTEfAAAAAC0tLSdubG3/gH59zFVVU1YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGxsbJSsoK7w6Njj/QT8+/0NBP/9JRET/SEJCtFtbSA4AAAAAAAAAAAAAAAAAAAAAAAAAAFdbWz1pamvyYWNj4zU1NRgAAAAAAAAAAAAAAAAAAAAAJC0tHDQ3OWZ/f40SAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMTDSQkInc2MzSHREJEpEVBP4xLSzwRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0lK14nKzXgJCo2KgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERIg8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGTNMCh8kNjgfLz8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Morgen"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhmtdEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYTAYFahwWjvEhm9XwIFpatSYfYTFj3OjuH5qv7J+a96ogWvtuZR90r6JdbvHh3SkwIBqj7iBZnipc11ok2JLWG5IMUMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM6VfT/DinTTyo909+imh//7t5f/7a+S/+KqkP/TnYb/vYt1/62Aav/Spo//1Z+I/9OUfP/YmHz/zZF0/72CZf+tc1r/rXdf+qd1XbJ3TDMeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADhqo9n9r2n9Pi9o//2w5r9562B/MuObPvJlX37r31o+6t+avyddGL8kWdX+6+EcfqugGj6uYVu+smQePrCjWb746x9++Onf/zGi3H9uIRp/5dqUdiFXUg/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5qWMaf3Dpv/zvKL+3ayO+/zcov3gs37/iVk4/29KOf2DX1L9ellO/2pNQ/9fQjj/dlNE/39aR/+NZlb/kGNR/9qxf///2Zb/4a12/plqS/yremH6qnte/5NpTe2RaVAzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL+NbTj5t6Dy/7yh/cyXeP2gd1b/99ql//bQm/+MZEL/SjUo/0o4Mf5HNi/sOy0q2jYoI8FELifGTTgt01M8Mt1aOCfp2K98+v/SlP+5iF3/akQt/5FiT/+rel/8mmtN/4xiStt4XE0kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5rCMvfa9m//tsI77qndd/1AtGvLAmnDk/9el/5ZoR/9EMCOfQDQwPzwsJi4xMScaAAAAAAAAAAAoGhoTNBoaHUsXESz1wZHS9L2R/oBROvZWNyWrfVE27suacv+0hl76j2NK/3ZUP4gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADhrobE58GU/v3Nofqmc1f6MxYWWbqCWE7wrIL9m19B/0scDlgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP+6kcbkrIr/ZzQkoAAAAAChdkuD/Nii/9ywh/iSaFP+eVpMjwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMyie7b406X//+Cx+6p9XvpbNik9AAAAAN6Ubr+6aEn+WRcNYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMGRkK+qJ/5qh0VOlDFAYmAAAAAOi8j3D/47H9qoBf9YNaSv9yVEyaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3LeOofXLn//vyZ34yI9t/3Q4I20AAAAA1ntTRuF8YP+BKR52AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP+OcCvUd1v/bzkcfAAAAAAAAAAA9sKXe//Lpf+EVzz0kmxV/29TQ7UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/2Km59c2i/5xzTvfIjG3/i0MvfAAAAAAAAAAA4YNsvLdgTJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/5x9ashtVdgzAAAPAAAAAAAAAAD4poW/0JB1yWlEKdWlgWH/gmZL9E8yHT0AAAAAAAAAAAAAAAAAAAAA8MWMR//ir/fuz6f+YkUnwLZ9aKm7a1zJAAAAAAAAAADbhnRIt2ZQpwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADng2GQuFlBYQAAAAAAAAAA/5FtI+6MbdqsWkMiel9CpsOhd/6jglz/WUcvswAAAAAAAAAAAAAAAAAAAADvv4i5/+69/7yhfP9JNR2B/8TrDdR5bsGqRj8kAAAAAAAAAACeTDhkeDwtEQAAAAAAAAAAAAAAAAAAAAAAAAAA0lpLEeBzVV0AAAAAAAAAAAAAAAD8knR48oxtaQAAAACDZ0Zl1rWI/8SfcvxnUDb/QDQnUwAAAAAAAAAA46RzSffQnv7axp3/WUsyyzUVChgAAAAA12tdNJ5BOToAAAAAAAAAALlcRQsAAAAAAAAAAAAAAACISD8cAAAAAAAAAAAAAAAAuVxFCwAAAAAAAAAAAAAAAOt3ZEIAAAAAAAAAAAAAAAC5kGqS6cCM/p56Vf9aQS6vAAAAAAAAAAD2vYWX/+az/498XPgeHg9CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAx494N5xbTW3MbGA9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJlmTB780qD1zqd9/3JUP80tHh4RAAAAAPzNj6v/77n/l3tf6AAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNemmarmNZachwZJYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAalU/DAAAAAAAAAAAv5RqJPvOovbOp33/dFpC4T8xKiQAAAAA+NCRxP7ut/+XdVvqAAAAEAAAAACZUD5Jlkc6JwAAAAAAAAAA7YxyHQAAAAAAAAAA9oNXHbRmVeiKVVxItWdQ0WosFlsAAAAAAAAAAGpVPwxtVVUVAAAAAAAAAACwfWlLvYptIwAAAACve1tA+Muk/NCqf/90Wz/uPywsNN2bYxfwypDV/Nil/6V+YfxtUUCmUz4pMbR5WJvNiWJOAAAAAKxlTkSnY05+AAAAAAAAAADinm98roBl/zYoMjjhjWevlksv2RkAAAoAAAAAplhNF69jVHbMf2YKAAAAAOemiHnNiW9inmhLYuO8mer/27j/0Kl9/nNbPPBCLy82yJJkId2wf97wwJP/67mV/cKTdP+FXUfvsXtc8tqadJMAAAAAq3FYjZtlTrMAAAAA6bR0GPnFjNueelr+BQoUMv+xgoPUe1P/ZysTdgAAAADljHIUvW5Sx4c9JT4AAAAA6rKLocSGYe/vvpr8/+C0/+e3iv3HmXL/dVg+7zosGjnLm3E21qV379CacPzbonn95amB+7uJaf/RnHv/0Zp2/1QyHp3Fk3Lenm5O0AAAAAD/355q/MaI/4NaPfgABg0l/76Ra/Ghd/58Sy3pOSwMKAAAAADVlHHXh1M1vp2AZpXnvZX4vIdc/+SzjP3Pn3P+s4NT/aJ4Vv1rTzr8PjMhRaqEWjC5jWfo0Jtz/86WbfrEimL9woxl/tOgeP6qdlL/kGBB/9+thv+NXjzraUMtk+u3gt3zuIb+hVQ6+zsXD2PemXiH9LGN/4VcPP9fQSTDzZRulPe9mPGRYkP/q4dt/76Scv+ygl/+rXxa/6x+Xf2RbUz+a1A0/086J7NVPDwVAAAAAIVnSCqqgGCzvIxp/7yEYf+3gl37sXte/p1lUP+/gmn90Zp7/pxsUP+qeFz/2Z1w/82NZ/+ZYEv+nWlc/NSTf/rfpIf9hlk8/bGGbP/7wJ3/8beT/613XP2yf2z8q3Vg/q11Xf6odVz8j2hR/2FHNPRNPCd6AAAAAAAAAAAAAAAAAAAAAAAAAACbc1tfq31g4bV/X/+obVT+qGlY+7l1YPu9gmT9uIRo/sGHafvJh2H6uXFW+8J/cP/AgHL/y4N5/8mKdP+xeV//1ZeD+uShhfnRmHX8s4Fj+59rV/ucZlf+omxZ/5RnUf9lRzfOQTEpPgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtSC0clGlPoJppVvOZY1b/l15P/5lmUv+ca1X/pGtY/6VrVP+la1v/kl9T6YNOQriMUE+ekFtQ1JloVvSfaVj/rXNc/6x7X/+NXUf/fEs7/31TQ/iFWUnlcU86lEgkJA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcVFEOHVRSmp1TESWcVFEzG1NRPlwS0XrcU1HqG5LQ19jUEQpAAAAAAAAAAAzJiYUVzk0OmlOO2+CV0SugVRBs3JGOoNmPTFoZEUyQnVSRCUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARj84JEczMxkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
			["Asksvin"] = "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",
			["Fader"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkZGRDpeQfCUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMSmcqMyoeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKiHlabm5gagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAT01KYERGQ5wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAysq4HY2IesRQUEQpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXFpWuVRRS5cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANnPxhuEfnXVbWldgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERDseV1RK64B7cK5jY1gXAAAAAAAAAAAAAAAAAAAAAAAAAABxcXESAAAAAAAAAAAzPzMUAAAAAAAAAAAAAAAAAAAAAAAAAACXj4dAkIeA5E1EQLIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABWXEsshoN15oyIgeahn5Z1XFxFCwAAAAAAAAAAbGxlSUZLRHcAAAAAAAAAADI4MIQsMChFAAAAAAAAAABcZFUhWlxOo2diV/9lXVjHPyo/DAAAAAAAAAAAAAAAAAAAAAAAAAAAZGpeKx8rLYElODVRJDYwKiYzMxQAAAAAAAAAAAAAAABjalwkd3Zwt21rYv9RUUa1Ojo1MFBTTEZAQDvCGh0WTgAAAAAAAAAALTEtThwfGsM0NDBJWmFWRDpAOtIpLCX/My8ngQAAAAAAAAAAZkxMCmBbVjVGWVFeSFlRg2ZwasdaYFn+HCsr/xopJ/8rODPoRExI0mJoY7BeYl56KysmNQAAAAAAAAAAHh4ZZTAyKv8zNy3ZMTMtriYnI+YAAAAAGTMzCjlBOR8AAAAAJCQf3jEwLchESkfjEBYX+wAAAEQAAAAAPTMoGV9bVXtnZF/DY2Ne7lFgWP9UZF3/VWBZ/1BXTu8TIB+cFCAf6ykxMv9LU1H/YGZj/2NnZP9maWj4VlpXriYqKkgzMzkoJSUgnjs7Nf9BQj78GhsW+x0iHWhZZFytOUE81klSUGwqLin1LzMu/xwhIf8XGBu6Qz1DV0hEQoJ0dGzhY2Vc/0hMQ/9GTEX/NkA+/ys2NOAzPDmPMTgxJAAAAAAWIictDxUcdCsyNLw7Qj7wQ0lG/21zcf9PVVP/Ki8t/CInJvEeHx/lGxga+ggIB/8YFxL/TE1D/3iAcv9aXVP/P0I8/x0iHP8cIRv/ChAN/TIwMPdgV1j/WldU/11hWv8/Rz//Iiki4isxLKAiLy1gBxUcJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACcxJxo7QT5eNTs6tCInJfMYHhz/FhsZ/w8RFf8EAwv/FRgV/zQvK/9mYFT9rq+Y/YyNd/5wb1r8W1lN/isvKv8UGxn/Gx0b/zc0M/8lJyb/HyUl1BYdG28AAAATAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHyMjOQkPDaQNEhD8CxAS/wACDP8zNjb/gn90/6Sgif6enYH+e3to/3h3Zf9FST3+Ex0a/w8TEf4YGhf6DA8N5gcLCYAiIiIWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERER0MERRkCA0R6gcSDf9lbFn+jpV3/6Gvi/9tf2D/PUcx/zI+L/8RIRj8DxAR/xMTEo0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPDw8QFxoaYA0TEKwaJSH0Oks8/lRiTv5cak7/i595/2J/U/8sQCD/HC4Y/xcsG/8VHRv+DBAP5CIlI7pCQEBzUFBQEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQERAQw0TEckMDg7SERkUyDRJOfpBVUT/OUY1/4SIc/+vq5P/goFr/zQ/Mv8GHg//DywW/BIsG/8TJB3FDxQUkzQzN8dCQkJ6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/Pz8kBQoFMQAAAAAqMSpITFpN/D5QPv4eLRr/Qkk2/36Ccf9QW03/Fy0i/wcnFf8UOh78GTUh/xknHsEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNhHobZ2VdhSQlIOc+RD/+fIp6+2l6Zf00RzP/IDYk/wwsGv8JLhj/GTsl/hQvHvwMGxb7AAgD/yUmIOpmY12LaWlaEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAenFtOGNhWOdjYln/TU9I/TlAPf86RTv/WWpa/3KKdv87W0X/MVY9/ztjR/8dOCj/FyAi/w0OF/8ECQn/Jiok/WdlXf9oZF3IUlJLIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHp2cTZuamTmSEhC/zM2LfojKyP/BhAM5ScxLo8bKiPMY3ts/WKGbv1CalH9OFtG/BgsJN8kKjJ+DQ0TgAcNDOcHDwj/Ozw2/Hd3cP9pa2HTbW1hFQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfnt0s1FQSv8KDwz/ChEN9AcRD4UAAAAsAAAAAC5COE1VaWD/WW9m/zxVTPkeMS3/BxMTrgAAAAAAAAAADRMTJwcNB4MYGhXwX15X/4KAdv9mZFdmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALi4px1fX1j0GRwZ/wcLC64KGRkzAAAAAAAAAABph3gRNExF1EdXU91NWlrlLDc9/CoyOsEOFRn3KDMzWQAAAAAAAAAAAAAAABwcFSRCQjqgcG5j/4J/c6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjI+AaVVWUP8MDg6OAAAAAAAAAAAAAAAAAAAAAC5EPYkUKiPHAAAAGw8aGjAOGRxHAAAAACkzN2lDTUzfMDwwFQAAAAAAAAAAAAAAAAAAAABlZVnEZGZZ5UpKShgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABzcWR1Y2Na+zo1MTkAAAAAAAAAAAAAAAB/jH8oLTo3qgAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAFJdWXVrcGloAAAAAAAAAAAAAAAAAAAAAIaGc7xOUkbcAAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIWBbkWGgXT/T01CdwAAAAAAAAAAAAAAAF9nXyA1NTUTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIyMfxQAAAAAAAAAAAAAAAB9cmNFXFxQ/y4zLJoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIqBddBRS0fZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFJMQXwzMS7YHh4eIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCQkKjMsKWgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASDw8FUU5ORYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="
		};
	}
	public static class LogoAssets
	{
		private static Texture2D _logo;

		private const int SRC_W = 80;

		private const int SRC_H = 16;

		private const string RAW_B64 = "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";

		public static Texture2D GetLogo()
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00ee: 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_00f8: 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)
			if ((Object)(object)_logo != (Object)null)
			{
				return _logo;
			}
			try
			{
				byte[] array = Convert.FromBase64String("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");
				int num = 16;
				int num2 = 80;
				byte[] array2 = new byte[num * num2 * 4];
				for (int i = 0; i < num2; i++)
				{
					for (int j = 0; j < num; j++)
					{
						int num3 = i;
						int num4 = (j * 80 + num3) * 4;
						int num5 = (i * num + j) * 4;
						array2[num5] = array[num4];
						array2[num5 + 1] = array[num4 + 1];
						array2[num5 + 2] = array[num4 + 2];
						array2[num5 + 3] = array[num4 + 3];
					}
				}
				_logo = new Texture2D(num, num2, (TextureFormat)4, false);
				Color[] array3 = (Color[])(object)new Color[num * num2];
				for (int k = 0; k < num * num2; k++)
				{
					int num6 = k * 4;
					byte b = array2[num6 + 3];
					if (b < 10)
					{
						array3[k] = Color.clear;
					}
					else
					{
						array3[k] = Color32.op_Implicit(new Color32(array2[num6], array2[num6 + 1], array2[num6 + 2], b));
					}
				}
				_logo.SetPixels(array3);
				((Texture)_logo).filterMode = (FilterMode)1;
				_logo.Apply(false, true);
			}
			catch (Exception ex)
			{
				Log.E("LogoAssets: failed to load logo: " + ex.Message);
			}
			return _logo;
		}
	}
	public class StatsWebClient
	{
		private static StatsWebClient _instance;

		private ModConfig _config;

		private readonly HttpClient _client;

		private ConcurrentQueue<string> _logQueue;

		private Timer _sendTimer;

		private int _isSending;

		public static StatsWebClient Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new StatsWebClient();
				}
				return _instance;
			}
		}

		private StatsWebClient()
		{
			//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_0025: Expected O, but got Unknown
			_client = new HttpClient
			{
				Timeout = TimeSpan.FromSeconds(5.0)
			};
			_logQueue = new ConcurrentQueue<string>();
			_sendTimer = new Timer(FlushLogs, null, 5000, 5000);
		}

		public void Initialize(ModConfig config)
		{
			_config = config;
		}

		public void SendLogEvent(string logLine)
		{
			if (!string.IsNullOrEmpty(logLine) && _config != null && !string.IsNullOrEmpty(_config.ApiEndpoint?.Value))
			{
				_logQueue.Enqueue(logLine);
			}
		}

		private async void FlushLogs(object state)
		{
			if (Interlocked.CompareExchange(ref _isSending, 1, 0) != 0 || _logQueue.IsEmpty)
			{
				return;
			}
			try
			{
				if (_config == null || string.IsNullOrEmpty(_config.ApiEndpoint?.Value))
				{
					return;
				}
				string steamId = ActivityLogger.GetSteamId();
				string url = _config.ApiEndpoint.Value + "?steam_id=" + steamId;
				string result;
				while (_logQueue.TryDequeue(out result))
				{
					try
					{
						StringContent val = new StringContent(result, Encoding.UTF8, "text/plain");
						await _client.PostAsync(url, (HttpContent)(object)val);
					}
					catch
					{
					}
				}
			}
			finally
			{
				Interlocked.Exchange(ref _isSending, 0);
			}
		}

		public void LoadPendingStats()
		{
		}
	}
}
namespace GCValheimStats.UI
{
	public class KillFeed : MonoBehaviour
	{
		private struct KillEntry
		{
			public string mobName;

			public int totalCount;

			public Dictionary<int, int> starBreakdown;

			public Texture2D icon;
		}

		private static KillFeed instance;

		private const float MainIconSize = 28f;

		private const float TooltipIconSize = 32f;

		private const float MainTrophySize = 12f;

		private readonly Dictionary<string, KillEntry> entries = new Dictionary<string, KillEntry>();

		private readonly Dictionary<string, Texture2D> textureCache = new Dictionary<string, Texture2D>();

		private readonly Dictionary<string, Texture2D> trophyTextureCache = new Dictionary<string, Texture2D>();

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

		private float trophyCountCacheTime;

		private bool showAllIcons;

		private float lastShowTime;

		private string hoveredMob;

		private float hoverX;

		private float hoverY;

		private static readonly Dictionary<string, string> TrophyKeys = new Dictionary<string, string>
		{
			["Eikthyr"] = "$item_trophy_eikthyr",
			["The Elder"] = "$item_trophy_theelder",
			["Bonemass"] = "$item_trophy_bonemass",
			["Moder"] = "$item_trophy_dragonqueen",
			["Yagluth"] = "$item_trophy_goblinking",
			["The Queen"] = "$item_trophy_seekerqueen",
			["Fader"] = "$item_trophy_fader",
			["Boar"] = "$item_trophy_boar",
			["Deer"] = "$item_trophy_deer",
			["Greydwarf"] = "$item_trophy_greydwarf",
			["Greydwarf Brute"] = "$item_trophy_greydwarfbrute",
			["Greydwarf Shaman"] = "$item_trophy_greydwarfshaman",
			["Skeleton"] = "$item_trophy_skeleton",
			["Rancid Remains"] = "$item_trophy_skeletonpoison",
			["Ghost"] = "$item_trophy_ghost",
			["Troll"] = "$item_trophy_frosttroll",
			["Bear"] = "$item_trophy_bjorn",
			["Serpent"] = "$item_trophy_serpent",
			["Abomination"] = "$item_trophy_abomination",
			["Blob"] = "$item_trophy_blob",
			["Draugr"] = "$item_trophy_draugr",
			["Draugr Elite"] = "$item_trophy_draugrelite",
			["Leech"] = "$item_trophy_leech",
			["Surtling"] = "$item_trophy_surtling",
			["Wraith"] = "$item_trophy_wraith",
			["Kvastur"] = "$item_trophy_kvastur",
			["Wolf"] = "$item_trophy_wolf",
			["Drake"] = "$item_trophy_hatchling",
			["Fenring"] = "$item_trophy_fenring",
			["Stone Golem"] = "$item_trophy_sgolem",
			["Ulv"] = "$item_trophy_ulv",
			["Cultist"] = "$item_trophy_cultist",
			["Deathsquito"] = "$item_trophy_deathsquito",
			["Lox"] = "$item_trophy_lox",
			["Fuling"] = "$item_trophy_goblin",
			["Fuling Shaman"] = "$item_trophy_goblinshaman",
			["Growth"] = "$item_trophy_growth",
			["Seeker"] = "$item_trophy_seeker",
			["Seeker Soldier"] = "$item_trophy_seekerbrute",
			["Gjall"] = "$item_trophy_gjall",
			["Tick"] = "$item_trophy_tick",
			["Dvergr Rogue"] = "$item_trophy_dvergr",
			["Bonemaw"] = "$item_trophy_bonemawserpent",
			["Fallen Valkyrie"] = "$item_trophy_fallenvalkyrie",
			["Charred Warlock"] = "$item_trophy_charredmage",
			["Charred Warrior"] = "$item_trophy_charredmelee",
			["Charred Marksman"] = "$item_trophy_charredarcher",
			["Volture"] = "$item_trophy_volture",
			["Morgen"] = "$item_trophy_morgen",
			["Asksvin"] = "$item_trophy_asksvin",
			["Hare"] = "$item_trophy_hare",
			["Brenna"] = "$item_trophy_brenna",
			["Geirrhafa"] = "$item_trophy_geirrhafa",
			["Lord Reto"] = "$item_trophy_lordreto",
			["Neck"] = "$item_trophy_neck",
			["Greyling"] = "$item_trophy_greyling",
			["Oozer"] = "$item_trophy_blobelite",
			["Bat"] = "$item_trophy_bat",
			["Vile"] = "$item_trophy_vile",
			["Fuling Berserker"] = "$item_trophy_goblinbrute",
			["Seeker Brood"] = "$item_trophy_seekerbrood",
			["Dvergr Mage"] = "$item_trophy_dvergrmage",
			["Lava Blob"] = "$item_trophy_lavablob",
			["Charred Twitcher"] = "$item_trophy_charredtwitcher",
			["Zil"] = "$item_trophy_shamanbro",
			["Thunder"] = "$item_trophy_goblinbrute_hildir"
		};

		public static KillFeed Instance
		{
			get
			{
				//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_0027: Expected O, but got Unknown
				if ((Object)(object)instance == (Object)null)
				{
					GameObject val = new GameObject("GCValheimStats_KillFeed");
					instance = val.AddComponent<KillFeed>();
					Object.DontDestroyOnLoad((Object)val);
				}
				return instance;
			}
		}

		private void Awake()
		{
			if ((Object)(object)instance == (Object)null)
			{
				instance = this;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			}
			else if ((Object)(object)instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		public void RegisterKill(string mobName, int stars)
		{
			Texture2D mobTexture = GetMobTexture(mobName);
			if (entries.TryGetValue(mobName, out var value))
			{
				if (!value.starBreakdown.ContainsKey(stars))
				{
					value.starBreakdown[stars] = 0;
				}
				value.starBreakdown[stars]++;
				int num = 0;
				foreach (int value3 in value.starBreakdown.Values)
				{
					num += value3;
				}
				value.totalCount = num;
				entries[mobName] = value;
			}
			else
			{
				KillEntry value2 = new KillEntry
				{
					mobName = mobName,
					totalCount = 1,
					starBreakdown = new Dictionary<int, int>(),
					icon = mobTexture
				};
				value2.starBreakdown[stars] = 1;
				entries[mobName] = value2;
			}
			showAllIcons = true;
			lastShowTime = Time.realtimeSinceStartup;
		}

		public void ShowAllIcons()
		{
			Dictionary<string, int> dictionary = StatsTracker.Instance?.sessionStats?.mobKills;
			string[] orderedNames = MobIcons.OrderedNames;
			foreach (string text in orderedNames)
			{
				if (entries.ContainsKey(text))
				{
					continue;
				}
				int num = 0;
				Dictionary<int, int> dictionary2 = new Dictionary<int, int>();
				if (dictionary != null)
				{
					foreach (KeyValuePair<string, int> item in dictionary)
					{
						if (!(item.Key == text) && !item.Key.StartsWith(text + " "))
						{
							continue;
						}
						num += item.Value;
						int key = 0;
						if (item.Key != text)
						{
							string text2 = item.Key.Substring(text.Length + 1);
							int num2 = text2.LastIndexOf(' ');
							if (num2 >= 0 && text2.EndsWith("*") && int.TryParse(text2.Substring(num2 + 1).TrimEnd(new char[1] { '*' }), out var result))
							{
								key = result - 1;
							}
						}
						if (!dictionary2.ContainsKey(key))
						{
							dictionary2[key] = 0;
						}
						dictionary2[key] += item.Value;
					}
				}
				entries[text] = new KillEntry
				{
					mobName = text,
					totalCount = num,
					starBreakdown = dictionary2,
					icon = GetMobTexture(text)
				};
			}
			showAllIcons = true;
			lastShowTime = Time.realtimeSinceStartup;
		}

		public void Hide()
		{
			showAllIcons = false;
			entries.Clear();
		}

		public void Reset()
		{
			foreach (string item in new List<string>(entries.Keys))
			{
				KillEntry value = entries[item];
				value.totalCount = 0;
				value.starBreakdown.Clear();
				entries[item] = value;
			}
		}

		private int GetTrophyCount(string mobName)
		{
			if (Time.realtimeSinceStartup - trophyCountCacheTime < 0.5f && trophyCountCache.TryGetValue(mobName, out var value))
			{
				return value;
			}
			Dictionary<string, int> dictionary = StatsTracker.Instance?.sessionStats?.trophies;
			if (dictionary == null || dictionary.Count == 0)
			{
				trophyCountCache[mobName] = 0;
				return 0;
			}
			int num = 0;
			if (TrophyKeys.TryGetValue(mobName, out string value2) && dictionary.TryGetValue(value2, out var value3))
			{
				num = value3;
			}
			if (num == 0)
			{
				string value4 = mobName.ToLowerInvariant();
				foreach (KeyValuePair<string, int> item in dictionary)
				{
					if (item.Key.ToLowerInvariant().Contains(value4) && item.Value > 0)
					{
						num = item.Value;
						break;
					}
				}
			}
			if (Time.realtimeSinceStartup - trophyCountCacheTime >= 0.5f)
			{
				trophyCountCache.Clear();
			}
			trophyCountCache[mobName] = num;
			trophyCountCacheTime = Time.realtimeSinceStartup;
			return num;
		}

		private Texture2D GetMobTexture(string mobName)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_00d4: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			if (textureCache.TryGetValue(mobName, out Texture2D value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			if (!MobIcons.Icons.TryGetValue(mobName, out string value2))
			{
				Log.W("KillFeed: no icon for '" + mobName + "'");
				return null;
			}
			try
			{
				byte[] array = Convert.FromBase64String(value2);
				int num = 32;
				Texture2D val = new Texture2D(num, num, (TextureFormat)4, false);
				((Texture)val).filterMode = (FilterMode)0;
				Color32[] array2 = (Color32[])(object)new Color32[num * num];
				int num2 = num * 4;
				for (int i = 0; i < num; i++)
				{
					int num3 = (num - 1 - i) * num2;
					int num4 = i * num;
					for (int j = 0; j < num; j++)
					{
						int num5 = num3 + j * 4;
						int num6 = num4 + j;
						byte b = array[num5];
						byte b2 = array[num5 + 1];
						byte b3 = array[num5 + 2];
						byte b4 = array[num5 + 3];
						array2[num6] = ((b4 < 10) ? new Color32((byte)0, (byte)0, (byte)0, (byte)0) : new Color32(b, b2, b3, b4));
					}
				}
				val.SetPixels32(array2);
				val.Apply();
				textureCache[mobName] = val;
				return val;
			}
			catch (Exception ex)
			{
				Log.E("KillFeed texture error: " + ex.Message);
				return null;
			}
		}

		private Texture2D GetTrophyTexture(string mobName)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_00bf: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			if (trophyTextureCache.TryGetValue(mobName, out Texture2D value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			if (!MobIcons.TrophyIcons.TryGetValue(mobName, out string value2))
			{
				return null;
			}
			try
			{
				byte[] array = Convert.FromBase64String(value2);
				int num = 32;
				Texture2D val = new Texture2D(num, num, (TextureFormat)4, false);
				((Texture)val).filterMode = (FilterMode)0;
				Color32[] array2 = (Color32[])(object)new Color32[num * num];
				int num2 = num * 4;
				for (int i = 0; i < num; i++)
				{
					int num3 = (num - 1 - i) * num2;
					int num4 = i * num;
					for (int j = 0; j < num; j++)
					{
						int num5 = num3 + j * 4;
						int num6 = num4 + j;
						byte b = array[num5];
						byte b2 = array[num5 + 1];
						byte b3 = array[num5 + 2];
						byte b4 = array[num5 + 3];
						array2[num6] = ((b4 < 10) ? new Color32((byte)0, (byte)0, (byte)0, (byte)0) : new Color32(b, b2, b3, b4));
					}
				}
				val.SetPixels32(array2);
				val.Apply();
				trophyTextureCache[mobName] = val;
				return val;
			}
			catch (Exception ex)
			{
				Log.E("KillFeed trophy texture error: " + ex.Message);
				return null;
			}
		}

		private static string StarString(int stars)
		{
			if (stars <= 0)
			{
				return "";
			}
			return new string('★', stars);
		}

		private void OnGUI()
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_064b: 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_0104: 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_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_01cc: 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_021a: 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_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_0416: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: Expected O, but got Unknown
			//IL_0422: Expected O, but got Unknown
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_043b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_047b: Expected O, but got Unknown
			//IL_047d: Expected O, but got Unknown
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04af: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bf: Expected O, but got Unknown
			//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0516: Unknown result type (might be due to invalid IL or missing references)
			//IL_0560: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_054b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0610: Unknown result type (might be due to invalid IL or missing references)
			//IL_062e: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fb: Unknown result type (might be due to invalid IL or missing references)
			if (!showAllIcons || entries.Count == 0)
			{
				return;
			}
			float num = Screen.height;
			float num2 = Screen.width;
			float num3 = 28f;
			float num4 = num - 28f - 20f;
			int num5 = 0;
			string[] orderedNames = MobIcons.OrderedNames;
			foreach (string key in orderedNames)
			{
				if (entries.ContainsKey(key))
				{
					num5++;
				}
			}
			float num6 = (float)num5 * num3;
			float num7 = (num2 - num6) / 2f;
			Vector2 mousePosition = Event.current.mousePosition;
			hoveredMob = null;
			int num8 = 0;
			orderedNames = MobIcons.OrderedNames;
			Rect val = default(Rect);
			foreach (string key2 in orderedNames)
			{
				if (entries.TryGetValue(key2, out var value))
				{
					float num9 = num7 + (float)num8 * num3;
					if (num9 + num3 > num2)
					{
						break;
					}
					((Rect)(ref val))..ctor(num9, num4, 28f, 28f);
					if (value.totalCount == 0)
					{
						GUI.color = new Color(1f, 1f, 1f, 0.33f);
					}
					else
					{
						GUI.color = Color.white;
					}
					if ((Object)(object)value.icon != (Object)null)
					{
						GUI.DrawTexture(val, (Texture)(object)value.icon, (ScaleMode)2, true);
					}
					GUI.color = Color.white;
					int trophyCount = GetTrophyCount(value.mobName);
					Texture2D trophyTexture = GetTrophyTexture(value.mobName);
					if ((Object)(object)trophyTexture != (Object)null && trophyCount > 0)
					{
						GUI.DrawTexture(new Rect(num9 + 28f - 12f - 1f, num4 - 6f, 12f, 12f), (Texture)(object)trophyTexture, (ScaleMode)2, true);
					}
					GUIStyle val2 = new GUIStyle(GUIStyle.none)
					{
						fontSize = 9,
						fontStyle = (FontStyle)1,
						alignment = (TextAnchor)4
					};
					val2.normal.textColor = Color.white;
					string text = ((value.totalCount > 0) ? $"{value.totalCount}" : "0");
					GUI.Label(new Rect(num9 - 2f, num4 + 28f, num3 + 4f, 12f), text, val2);
					if (((Rect)(ref val)).Contains(mousePosition))
					{
						hoveredMob = key2;
						hoverX = mousePosition.x;
						hoverY = mousePosition.y;
					}
					num8++;
				}
			}
			if (hoveredMob != null && entries.TryGetValue(hoveredMob, out var value2))
			{
				int trophyCount2 = GetTrophyCount(value2.mobName);
				Dictionary<int, int> starBreakdown = value2.starBreakdown;
				List<int> list = new List<int>();
				foreach (KeyValuePair<int, int> item in starBreakdown)
				{
					list.Add(item.Key);
				}
				list.Sort();
				if (list.Count == 0)
				{
					list.Add(0);
				}
				bool flag = trophyCount2 > 0;
				int num10 = list.Count + (flag ? 1 : 0);
				float num11 = 4f;
				float num12 = 32f + num11;
				float num13 = 12f;
				float num14 = 32f + num13;
				float num15 = 16f;
				float num16 = 6f;
				float num17 = (float)num10 * num12 - num11 + num16 * 2f;
				float num18 = num15 + num14 + num16 * 2f;
				float num19 = hoverX + 16f;
				float num20 = hoverY - num18 - 4f;
				if (num19 + num17 > num2)
				{
					num19 = num2 - num17 - 4f;
				}
				if (num20 < 0f)
				{
					num20 = hoverY + 20f;
				}
				GUI.color = new Color(0f, 0f, 0f, 0.25f);
				GUI.DrawTexture(new Rect(num19, num20, num17, num18), (Texture)(object)Texture2D.whiteTexture, (ScaleMode)0);
				GUI.color = Color.white;
				GUIStyle val3 = new GUIStyle(GUIStyle.none)
				{
					fontSize = 11,
					fontStyle = (FontStyle)1,
					alignment = (TextAnchor)4,
					padding = new RectOffset(4, 4, 2, 2)
				};
				val3.normal.textColor = Color.white;
				GUI.Label(new Rect(num19, num20, num17, num15), hoveredMob, val3);
				GUIStyle val4 = new GUIStyle(GUIStyle.none)
				{
					fontSize = 8,
					fontStyle = (FontStyle)1,
					alignment = (TextAnchor)2,
					padding = new RectOffset(0, 1, 0, 0)
				};
				val4.normal.textColor = new Color(1f, 0.84f, 0f);
				GUIStyle val5 = new GUIStyle(GUIStyle.none)
				{
					fontSize = 9,
					fontStyle = (FontStyle)1,
					alignment = (TextAnchor)4
				};
				float num21 = num20 + num15 + num16;
				float num22 = num19 + num16;
				for (int j = 0; j < list.Count; j++)
				{
					int num23 = list[j];
					starBreakdown.TryGetValue(num23, out var value3);
					GUI.color = Color.white;
					if ((Object)(object)value2.icon != (Object)null)
					{
						GUI.DrawTexture(new Rect(num22, num21, 32f, 32f), (Texture)(object)value2.icon, (ScaleMode)2, true);
					}
					if (num23 > 0)
					{
						string text2 = StarString(num23);
						GUI.Label(new Rect(num22, num21 - 11f, 32f, 10f), text2, val4);
					}
					val5.normal.textColor = Color.white;
					GUI.Label(new Rect(num22 - 2f, num21 + 32f, num12, num13), $"{value3}", val5);
					num22 += num12;
				}
				if (flag)
				{
					Texture2D trophyTexture2 = GetTrophyTexture(value2.mobName);
					if ((Object)(object)trophyTexture2 != (Object)null)
					{
						float num24 = 0f;
						GUI.color = Color.white;
						GUI.DrawTexture(new Rect(num22 + num24, num21 + num24, 32f, 32f), (Texture)(object)trophyTexture2, (ScaleMode)2, true);
					}
					val5.normal.textColor = Color.white;
					GUI.Label(new Rect(num22 - 2f, num21 + 32f, num12, num13), $"{trophyCount2}", val5);
				}
			}
			GUI.color = Color.white;
		}
	}
	public class MainMenuOverlay : MonoBehaviour
	{
		private bool _serverOnline;

		private int _pendingCount;

		private bool _initialized;

		private float _pingTimer;

		private const float PING_INTERVAL = 30f;

		private Rect _windowRect = new Rect(10f, 10f, 280f, 120f);

		private Rect _lastSavedRect;

		private string _configPath;

		private QueueStorage _storage;

		private StatsHttpClient _httpClient;

		private string _serverUrl;

		private string _steamId;

		private void Awake()
		{
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			_configPath = Path.Combine(Path.GetDirectoryName(typeof(GCValheimStatsPlugin).Assembly.Location) ?? "", "overlay_window.json");
		}

		public void Initialize(QueueStorage storage, StatsHttpClient httpClient, byte[] aesKey, byte[] hmacKey, string serverUrl, string steamId)
		{
			_storage = storage;
			_httpClient = httpClient;
			_serverUrl = serverUrl;
			_steamId = steamId;
			LoadPosition();
		}

		private void Update()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Player.m_localPlayer != (Object)null) && !((Object)(object)ZNet.instance != (Object)null))
			{
				if (!_initialized)
				{
					_initialized = true;
					CheckServerStatus();
				}
				_pingTimer += Time.unscaledDeltaTime;
				if (_pingTimer >= 30f)
				{
					_pingTimer = 0f;
					CheckServerStatus();
				}
				if (_storage != null)
				{
					_pendingCount = _storage.GetPendingCount();
				}
				if (_windowRect != _lastSavedRect && (Mathf.Abs(((Rect)(ref _windowRect)).x - ((Rect)(ref _lastSavedRect)).x) > 1f || Mathf.Abs(((Rect)(ref _windowRect)).y - ((Rect)(ref _lastSavedRect)).y) > 1f))
				{
					SavePosition();
				}
			}
		}

		private void OnGUI()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//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)
			if (!((Object)(object)Player.m_localPlayer != (Object)null) && !((Object)(object)ZNet.instance != (Object)null) && GCValheimStatsPlugin.Config != null && GCValheimStatsPlugin.Config.EnableMod.Value)
			{
				_windowRect = GUILayout.Window(((Object)this).GetInstanceID(), _windowRect, new WindowFunction(DrawWindow), "GCValheimStats", Array.Empty<GUILayoutOption>());
			}
		}

		private void DrawWindow(int windowID)
		{
			string text = (_serverOnline ? "● ONLINE" : "○ OFFLINE");
			GUILayout.Label("Server: " + text, Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Unsent batches: {_pendingCount}", Array.Empty<GUILayoutOption>());
			GUI.enabled = _pendingCount > 0;
			if (GUILayout.Button("Clear Batches", Array.Empty<GUILayoutOption>()))
			{
				_storage?.DeleteAllPending();
				_pendingCount = 0;
			}
			GUI.enabled = true;
			GUI.DragWindow();
		}

		private async Task CheckServerStatus()
		{
			if (_httpClient != null && !string.IsNullOrEmpty(_serverUrl))
			{
				string text = _serverUrl;
				int num = text.LastIndexOf('/');
				if (num > 0)
				{
					text = text.Substring(0, num);
				}
				string steamId = (((Object)(object)GCValheimStatsPlugin.Instance != (Object)null) ? GCValheimStatsPlugin.Instance.SteamId.ToString() : "0");
				_serverOnline = await _httpClient.PingServer(text, steamId);
			}
		}

		public static MainMenuOverlay GetInstance()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			MainMenuOverlay mainMenuOverlay = Object.FindObjectOfType<MainMenuOverlay>();
			if ((Object)(object)mainMenuOverlay != (Object)null)
			{
				return mainMenuOverlay;
			}
			return new GameObject("MainMenuOverlay").AddComponent<MainMenuOverlay>();
		}

		private void SavePosition()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!string.IsNullOrEmpty(_configPath))
				{
					string contents = "{\"x\":" + ((Rect)(ref _windowRect)).x.ToString(CultureInfo.InvariantCulture) + ",\"y\":" + ((Rect)(ref _windowRect)).y.ToString(CultureInfo.InvariantCulture) + "}";
					File.WriteAllText(_configPath, contents);
					_lastSavedRect = _windowRect;
				}
			}
			catch
			{
			}
		}

		private void LoadPosition()
		{
			//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)
			try
			{
				if (!string.IsNullOrEmpty(_configPath) && File.Exists(_configPath))
				{
					string input = File.ReadAllText(_configPath);
					float x = 10f;
					float y = 10f;
					Match match = Regex.Match(input, "\"x\":\\s*([\\d.\\-]+)");
					Match match2 = Regex.Match(input, "\"y\":\\s*([\\d.\\-]+)");
					if (match.Success)
					{
						x = float.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
					}
					if (match2.Success)
					{
						y = float.Parse(match2.Groups[1].Value, CultureInfo.InvariantCulture);
					}
					((Rect)(ref _windowRect)).x = x;
					((Rect)(ref _windowRect)).y = y;
					_lastSavedRect = _windowRect;
				}
			}
			catch
			{
			}
		}
	}
	public class StatsOverlay : MonoBehaviour
	{
		private static StatsOverlay instance;

		private bool showStats;

		private Rect windowRect = new Rect(10f, 10f, 300f, 400f);

		private Rect _lastSavedRect;

		private bool _isSending;

		private int _unsentCount;

		private string _configPath;

		public static StatsOverlay Instance
		{
			get
			{
				//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_0027: Expected O, but got Unknown
				if ((Object)(object)instance == (Object)null)
				{
					GameObject val = new GameObject("StatsOverlay");
					instance = val.AddComponent<StatsOverlay>();
					Object.DontDestroyOnLoad((Object)val);
				}
				return instance;
			}
		}

		private void Awake()
		{
			if ((Object)(object)instance == (Object)null)
			{
				instance = this;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
				_configPath = Path.Combine(Path.GetDirectoryName(typeof(GCValheimStatsPlugin).Assembly.Location) ?? "", "overlay_window.json");
				LoadPosition();
			}
			else
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void Update()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			if (StatsTracker.Instance != null && StatsTracker.Instance.IsTracking)
			{
				StatsTracker.Instance.Update();
			}
			if (GCValheimStatsPlugin.Config != null && GCValheimStatsPlugin.Config.EnableMod.Value)
			{
				KeyboardShortcut value = GCValheimStatsPlugin.Config.ToggleStatsKey.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					showStats = !showStats;
				}
				value = GCValheimStatsPlugin.Config.ResetStatsKey.Value;
				if (((KeyboardShortcut)(ref value)).IsDown() && StatsTracker.Instance != null)
				{
					StatsTracker.Instance.ResetSession();
					KillFeed.Instance.Reset();
				}
			}
			if (showStats && windowRect != _lastSavedRect && (Mathf.Abs(((Rect)(ref windowRect)).x - ((Rect)(ref _lastSavedRect)).x) > 1f || Mathf.Abs(((Rect)(ref windowRect)).y - ((Rect)(ref _lastSavedRect)).y) > 1f))
			{
				SavePosition();
			}
		}

		private void OnGUI()
		{
			//IL_0065: 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_0085: Expected O, but got Unknown
			//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)
			if (GCValheimStatsPlugin.Config != null && GCValheimStatsPlugin.Config.EnableMod.Value && GCValheimStatsPlugin.Config.ShowOnScreen.Value && !((Object)(object)Player.m_localPlayer == (Object)null) && StatsTracker.Instance != null && StatsTracker.Instance.IsTracking)
			{
				DrawBranding();
				if (showStats)
				{
					windowRect = GUILayout.Window(((Object)this).GetInstanceID(), windowRect, new WindowFunction(DrawStatsWindow), "GCValheimStats", Array.Empty<GUILayoutOption>());
				}
			}
		}

		private void DrawStatsWindow(int windowID)
		{
			PlayerStats sessionStats = StatsTracker.Instance.sessionStats;
			GUILayout.Label($"Distance: {sessionStats.maxDistance}m", Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			GUILayout.Label($"Damage Dealt: {sessionStats.damageDealt:F0}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Damage Taken: {sessionStats.damageTaken:F0}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Enemy Kills: {sessionStats.enemyKills}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Deaths: {sessionStats.deaths}", Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			GUILayout.Label($"Buildings: {sessionStats.buildingBuilt}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Trees: {sessionStats.treeChopped}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Mined: {sessionStats.mineRock}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Items Picked: {sessionStats.itemsPickedUp}", Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			GUILayout.Label($"Food: {sessionStats.foodConsumed}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Fish: {sessionStats.fishCaught}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Tamed: {sessionStats.tamedCount}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Trades: {sessionStats.tradeCount}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Portals: {sessionStats.portalUsed}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Sleep: {sessionStats.sleepCount}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Skill Ups: {sessionStats.skillUps}", Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			if (_isSending)
			{
				GUILayout.Label("<color=yellow>Sending...</color>", Array.Empty<GUILayoutOption>());
			}
			if (_unsentCount > 0)
			{
				GUILayout.Label($"<color=orange>Unsent: {_unsentCount}</color>", Array.Empty<GUILayoutOption>());
			}
			GUILayout.Space(10f);
			GUILayout.Label("Toggle: F7", Array.Empty<GUILayoutOption>());
			GUI.DragWindow();
		}

		public void SetSending(bool sending)
		{
			_isSending = sending;
		}

		public void SetUnsentCount(int count)
		{
			_unsentCount = count;
		}

		private void DrawBranding()
		{
			//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_00a3: Unknown result type (might be due to invalid IL or missing references)
			Texture2D logo = LogoAssets.GetLogo();
			if ((Object)(object)logo == (Object)null)
			{
				return;
			}
			float num = ((Texture)logo).width;
			float num2 = ((Texture)logo).height;
			float num3 = Screen.height;
			if (!((float)Screen.width < 640f) && !(num3 < 480f))
			{
				float num4 = num;
				float num5 = num2;
				float num6 = 2f;
				float num7 = num3 - 20f - num5;
				if (num7 < 0f)
				{
					num5 = num3 - 4f;
					num4 = num5 * (num / num2);
					num7 = 2f;
				}
				Color color = GUI.color;
				GUI.color = new Color(1f, 1f, 1f, 0.4f);
				GUI.DrawTexture(new Rect(num6, num7, num4, num5), (Texture)(object)logo);
				GUI.color = color;
			}
		}

		private string FormatTime(int seconds)
		{
			TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
			return $"{(int)timeSpan.TotalHours:D2}:{timeSpan.Minutes:D2}:{timeSpan.Seconds:D2}";
		}

		public static StatsOverlay GetInstance()
		{
			return instance;
		}

		private void SavePosition()
		{
			//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)
			try
			{
				if (!string.IsNullOrEmpty(_configPath))
				{
					string contents = "{\"x\":" + ((Rect)(ref windowRect)).x.ToString(CultureInfo.InvariantCulture) + ",\"y\":" + ((Rect)(ref windowRect)).y.ToString(CultureInfo.InvariantCulture) + "}";
					File.WriteAllText(_configPath, contents);
					_lastSavedRect = windowRect;
				}
			}
			catch (Exception ex)
			{
				Log.W("Failed to save overlay position: " + ex.Message);
			}
		}

		private void LoadPosition()
		{
			//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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (string.IsNullOrEmpty(_configPath) || !File.Exists(_configPath))
				{
					_lastSavedRect = windowRect;
					return;
				}
				string input = File.ReadAllText(_configPath);
				float x = 10f;
				float y = 10f;
				Match match = Regex.Match(input, "\"x\":\\s*([\\d.\\-]+)");
				Match match2 = Regex.Match(input, "\"y\":\\s*([\\d.\\-]+)");
				if (match.Success)
				{
					x = float.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
				}
				if (match2.Success)
				{
					y = float.Parse(match2.Groups[1].Value, CultureInfo.InvariantCulture);
				}
				((Rect)(ref windowRect)).x = x;
				((Rect)(ref windowRect)).y = y;
				EnsureVisible();
				_lastSavedRect = windowRect;
			}
			catch (Exception ex)
			{
				Log.W("Failed to load overlay position: " + ex.Message);
			}
		}

		private void EnsureVisible()
		{
			//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_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)
			Resolution currentResolution = Screen.currentResolution;
			float num = ((Resolution)(ref currentResolution)).width;
			currentResolution = Screen.currentResolution;
			float num2 = ((Resolution)(ref currentResolution)).height;
			if (num < 640f || num2 < 480f)
			{
				return;
			}
			float num3 = Mathf.Max(((Rect)(ref windowRect)).width, 300f);
			float num4 = Mathf.Max(((Rect)(ref windowRect)).height, 400f);
			if (((Rect)(ref windowRect)).x + num3 < 0f || ((Rect)(ref windowRect)).y + num4 < 0f || ((Rect)(ref windowRect)).x > num || ((Rect)(ref windowRect)).y > num2)
			{
				((Rect)(ref windowRect)).x = 10f;
				((Rect)(ref windowRect)).y = 10f;
				return;
			}
			if (((Rect)(ref windowRect)).x < 0f)
			{
				((Rect)(ref windowRect)).x = 10f;
			}
			if (((Rect)(ref windowRect)).y < 0f)
			{
				((Rect)(ref windowRect)).y = 10f;
			}
			if (((Rect)(ref windowRect)).x + num3 > num)
			{
				((Rect)(ref windowRect)).x = num - num3 - 10f;
			}
			if (((Rect)(ref windowRect)).y + num4 > num2)
			{
				((Rect)(ref windowRect)).y = num2 - num4 - 10f;
			}
		}
	}
	public class TimerOverlay : MonoBehaviour
	{
		private static TimerOverlay instance;

		private Rect windowRect = new Rect(10f, 10f, 110f, 40f);

		private Rect _lastSavedRect;

		private float _accumulatedSeconds;

		private float _sessionStartTime;

		private bool _timeSynced;

		private bool _timerActive;

		private string _currentTime = "00:00:00";

		private const string SAVE_KEY = "gcsv_playtime";

		private const string SAVE_POS = "gcsv_timerPos";

		public static TimerOverlay Instance
		{
			get
			{
				//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_0027: Expected O, but got Unknown
				if ((Object)(object)instance == (Object)null)
				{
					GameObject val = new GameObject("TimerOverlay");
					instance = val.AddComponent<TimerOverlay>();
					Object.DontDestroyOnLoad((Object)val);
				}
				return instance;
			}
		}

		private void Awake()
		{
			if ((Object)(object)instance == (Object)null)
			{
				instance = this;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			}
			else if ((Object)(object)instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			LoadPosition();
		}

		private void Update()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			if (windowRect != _lastSavedRect && (Mathf.Abs(((Rect)(ref windowRect)).x - ((Rect)(ref _lastSavedRect)).x) > 1f || Mathf.Abs(((Rect)(ref windowRect)).y - ((Rect)(ref _lastSavedRect)).y) > 1f))
			{
				SavePosition();
			}
		}

		private int LoadSavedPlayTime()
		{
			try
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					return 0;
				}
				Dictionary<string, string> customData = Player.m_localPlayer.m_customData;
				if (customData == null)
				{
					return 0;
				}
				if (customData.TryGetValue("gcsv_playtime", out var value) && int.TryParse(value, out var result))
				{
					return result;
				}
			}
			catch (Exception ex)
			{
				Log.W("Timer: failed to load saved time: " + ex.Message);
			}
			return 0;
		}

		private void SavePlayTime(int totalSeconds)
		{
			try
			{
				if (!((Object)(object)Player.m_localPlayer == (Object)null))
				{
					Dictionary<string, string> customData = Player.m_localPlayer.m_customData;
					if (customData != null)
					{
						customData["gcsv_playtime"] = totalSeconds.ToString();
					}
				}
			}
			catch (Exception ex)
			{
				Log.W("Timer: failed to save time: " + ex.Message);
			}
		}

		public void StartTimer()
		{
			if (!_timerActive)
			{
				_accumulatedSeconds = LoadSavedPlayTime();
				_sessionStartTime = Time.realtimeSinceStartup;
				_timeSynced = true;
				_timerActive = true;
				LoadPosition();
				((MonoBehaviour)this).StartCoroutine(TimerCoroutine());
			}
		}

		public void StopTimer()
		{
			if (_timerActive)
			{
				int totalSeconds = (int)(_accumulatedSeconds + (Time.realtimeSinceStartup - _sessionStartTime));
				SavePlayTime(totalSeconds);
				_timerActive = false;
			}
		}

		private IEnumerator TimerCoroutine()
		{
			while (_timerActive)
			{
				if ((Object)(object)Game.instance != (Object)null && (Object)(object)Player.m_localPlayer != (Object)null)
				{
					int num = (int)(Time.realtimeSinceStartup - _sessionStartTime);
					int num2 = (int)_accumulatedSeconds + num;
					_currentTime = FormatTime(num2);
					SavePlayTime(num2);
				}
				yield return (object)new WaitForSeconds(1f);
			}
		}

		private void OnGUI()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_007c: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_00a7: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			if (GCValheimStatsPlugin.Config != null && GCValheimStatsPlugin.Config.EnableMod.Value && GCValheimStatsPlugin.Config.ShowOnScreen.Value && !((Object)(object)Player.m_localPlayer == (Object)null) && _timeSynced)
			{
				GUIStyle val = new GUIStyle(GUIStyle.none);
				val.normal.background = null;
				val.border = new RectOffset(0, 0, 0, 0);
				GUIStyle labelStyle = new GUIStyle(GUIStyle.none)
				{
					fontSize = 16,
					fontStyle = (FontStyle)1,
					alignment = (TextAnchor)4
				};
				labelStyle.normal.textColor = Color.white;
				windowRect = GUILayout.Window(((Object)this).GetInstanceID(), windowRect, (WindowFunction)delegate
				{
					GUILayout.Label(_currentTime, labelStyle, Array.Empty<GUILayoutOption>());
					GUI.DragWindow();
				}, "", val, Array.Empty<GUILayoutOption>());
			}
		}

		private string FormatTime(int seconds)
		{
			TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
			return $"{(int)timeSpan.TotalHours:D2}:{timeSpan.Minutes:D2}:{timeSpan.Seconds:D2}";
		}

		private void SavePosition()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)Player.m_localPlayer == (Object)null))
				{
					Dictionary<string, string> customData = Player.m_localPlayer.m_customData;
					if (customData != null)
					{
						customData["gcsv_timerPos"] = ((Rect)(ref windowRect)).x.ToString(CultureInfo.InvariantCulture) + "," + ((Rect)(ref windowRect)).y.ToString(CultureInfo.InvariantCulture);
						_lastSavedRect = windowRect;
					}
				}
			}
			catch
			{
			}
		}

		private void LoadPosition()
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					return;
				}
				Dictionary<string, string> customData = Player.m_localPlayer.m_customData;
				if (customData == null)
				{
					return;
				}
				if (customData.TryGetValue("gcsv_timerPos", out var value) && !string.IsNullOrEmpty(value))
				{
					string[] array = value.Split(new char[1] { ',' });
					if (array.Length == 2 && float.TryParse(array[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
					{
						((Rect)(ref windowRect)).x = result;
						((Rect)(ref windowRect)).y = result2;
					}
				}
			}
			catch
			{
			}
			_lastSavedRect = windowRect;
		}
	}
}
namespace GCValheimStats.Patches
{
	[HarmonyPatch]
	public static class BlockPatches
	{
		private static bool IsLocalPlayer(Humanoid human)
		{
			if ((Object)(object)human != (Object)null)
			{
				return (Object)(object)human == (Object)(object)Player.m_localPlayer;
			}
			return false;
		}

		[HarmonyPatch(typeof(Humanoid), "BlockAttack")]
		[HarmonyPostfix]
		public static void Humanoid_BlockAttack_Postfix(Humanoid __instance, ref bool __result, Character attacker, HitData hit)
		{
			if (IsLocalPlayer(__instance) && __result)
			{
				string arg = (((Object)(object)attacker != (Object)null) ? ((Object)((Component)attacker).gameObject).name : "unknown");
				string arg2 = (((Object)(object)attacker != (Object)null) ? $" lvl:{attacker.GetLevel()}" : "");
				float num = ((hit != null) ? hit.GetTotalDamage() : 0f);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Block", $"attacker:{arg}{arg2} damage:{num:0.0}"));
			}
		}
	}
	[HarmonyPatch]
	public static class ConsumePatches
	{
		[HarmonyPatch(typeof(CookingStation), "UseItem")]
		[HarmonyPrefix]
		public static void CookingStation_UseItem_Prefix(CookingStation __instance, Humanoid user, ItemData item, ref bool __result)
		{
			if (!((Object)(object)user != (Object)(object)Player.m_localPlayer) && item != null)
			{
				string text = ActivityLogger.FormatItem(item);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Use", "target:" + ((Object)((Component)__instance).gameObject).name + " item:" + text));
			}
		}

		[HarmonyPatch(typeof(Fermenter), "UseItem")]
		[HarmonyPrefix]
		public static void Fermenter_UseItem_Prefix(Fermenter __instance, Humanoid user, ItemData item, ref bool __result)
		{
			if (!((Object)(object)user != (Object)(object)Player.m_localPlayer) && item != null)
			{
				string text = ActivityLogger.FormatItem(item);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Use", "target:" + ((Object)((Component)__instance).gameObject).name + " item:" + text));
			}
		}

		[HarmonyPatch(typeof(Fireplace), "UseItem")]
		[HarmonyPrefix]
		public static void Fireplace_UseItem_Prefix(Fireplace __instance, Humanoid user, ItemData item, ref bool __result)
		{
			if (!((Object)(object)user != (Object)(object)Player.m_localPlayer) && item != null)
			{
				string text = ActivityLogger.FormatItem(item);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Use", "target:" + ((Object)((Component)__instance).gameObject).name + " item:" + text));
			}
		}

		[HarmonyPatch(typeof(ItemStand), "UseItem")]
		[HarmonyPrefix]
		public static void ItemStand_UseItem_Prefix(ItemStand __instance, Humanoid user, ItemData item, ref bool __result)
		{
			if (!((Object)(object)user != (Object)(object)Player.m_localPlayer) && item != null)
			{
				string text = ActivityLogger.FormatItem(item);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Use", "target:" + ((Object)((Component)__instance).gameObject).name + " item:" + text));
			}
		}

		[HarmonyPatch(typeof(OfferingBowl), "UseItem")]
		[HarmonyPrefix]
		public static void OfferingBowl_UseItem_Prefix(OfferingBowl __instance, Humanoid user, ItemData item, ref bool __result)
		{
			if (!((Object)(object)user != (Object)(object)Player.m_localPlayer) && item != null)
			{
				string text = ActivityLogger.FormatItem(item);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Use", "target:" + ((Object)((Component)__instance).gameObject).name + " item:" + text));
			}
		}

		[HarmonyPatch(typeof(Switch), "UseItem")]
		[HarmonyPrefix]
		public static void Switch_UseItem_Prefix(Switch __instance, Humanoid user, ItemData item, ref bool __result)
		{
			if (!((Object)(object)user != (Object)(object)Player.m_localPlayer) && item != null)
			{
				string text = ActivityLogger.FormatItem(item);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Use", "target:" + ((Object)((Component)__instance).gameObject).name + " item:" + text));
			}
		}

		[HarmonyPatch(typeof(PrivateArea), "UseItem")]
		[HarmonyPrefix]
		public static void PrivateArea_UseItem_Prefix(PrivateArea __instance, Humanoid user, ItemData item, ref bool __result)
		{
			if (!((Object)(object)user != (Object)(object)Player.m_localPlayer) && item != null)
			{
				string text = ActivityLogger.FormatItem(item);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Use", "target:" + ((Object)((Component)__instance).gameObject).name + " item:" + text));
			}
		}
	}
	[HarmonyPatch]
	public static class CraftPatches
	{
		private static bool _isCrafting;

		[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
		[HarmonyPrefix]
		public static void InventoryGui_DoCrafting_Prefix(InventoryGui __instance)
		{
			_isCrafting = true;
		}

		[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
		[HarmonyPostfix]
		public static void InventoryGui_DoCrafting_Postfix(InventoryGui __instance)
		{
			_isCrafting = false;
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[] { typeof(ItemData) })]
		[HarmonyPrefix]
		public static void Inventory_AddItem_Prefix(Inventory __instance, ref ItemData item)
		{
			if (_isCrafting && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
				if (__instance == inventory && item != null)
				{
					string text = ActivityLogger.FormatItem(item);
					StatsTracker.Instance.RecordBuilding(text);
					ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Craft", text));
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(string),
			typeof(int),
			typeof(int),
			typeof(int),
			typeof(long),
			typeof(string),
			typeof(Vector2i),
			typeof(bool)
		})]
		[HarmonyPrefix]
		public static void Inventory_AddItem8_Prefix(Inventory __instance, string name, int stack, int quality, int variant, long crafterID, string crafterName, Vector2i position, bool pickedUp)
		{
			if (_isCrafting && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
				if (__instance == inventory)
				{
					ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Craft", $"name:{name} x{stack}"));
				}
			}
		}
	}
	[HarmonyPatch]
	public static class PickupPatches
	{
		[HarmonyPatch(typeof(Humanoid), "Pickup")]
		[HarmonyPrefix]
		public static void Humanoid_Pickup_Prefix(Humanoid __instance, GameObject go, bool autoequip, bool autoPickupDelay, ref bool __result)
		{
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || (Object)(object)go == (Object)null)
			{
				return;
			}
			ItemDrop component = go.GetComponent<ItemDrop>();
			if (!((Object)(object)component == (Object)null))
			{
				ItemData itemData = component.m_itemData;
				if (itemData != null)
				{
					string parameters = ActivityLogger.FormatItem(itemData);
					StatsTracker.Instance.RecordPickup(((Object)go).name);
					ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Pickup", parameters));
				}
			}
		}
	}
	[HarmonyPatch]
	public static class DodgePatches
	{
		[HarmonyPatch(typeof(Player), "UpdateDodge")]
		[HarmonyPostfix]
		public static void Player_UpdateDodge_Postfix(Player __instance, float dt)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && ((Character)__instance).IsDodgeInvincible())
			{
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Dodge"));
			}
		}
	}
	[HarmonyPatch]
	public static class PlayerRemovePiecePatches
	{
		[HarmonyPatch(typeof(Player), "RemovePiece")]
		[HarmonyPrefix]
		public static void Player_RemovePiece_Prefix(Player __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Remove"));
			}
		}
	}
	[HarmonyPatch]
	public static class RepairPatches
	{
		[HarmonyPatch(typeof(WearNTear), "Repair")]
		[HarmonyPrefix]
		public static void WearNTear_Repair_Prefix(WearNTear __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				string name = ((Object)((Component)__instance).gameObject).name;
				StatsTracker.Instance.RecordBuilding(name);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("RepairBuilding", name));
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "RepairOneItem")]
		[HarmonyPrefix]
		public static void InventoryGui_RepairOneItem_Prefix()
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("RepairItem"));
			}
		}
	}
	[HarmonyPatch]
	public static class SignPatches
	{
		[HarmonyPatch(typeof(Sign), "SetText")]
		[HarmonyPrefix]
		public static void Sign_SetText_Prefix(Sign __instance, string text)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				string name = ((Object)((Component)__instance).gameObject).name;
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Text", "target:" + name + " text:" + text));
			}
		}

		[HarmonyPatch(typeof(Tameable), "SetText")]
		[HarmonyPrefix]
		public static void Tameable_SetText_Prefix(Tameable __instance, string text)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				string name = ((Object)((Component)__instance).gameObject).name;
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Text", "target:" + name + " text:" + text));
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "SetText")]
		[HarmonyPrefix]
		public static void TeleportWorld_SetText_Prefix(TeleportWorld __instance, string text)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				string name = ((Object)((Component)__instance).gameObject).name;
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Text", "target:" + name + " text:" + text));
			}
		}
	}
	[HarmonyPatch]
	public static class TombStonePatches
	{
		[HarmonyPatch(typeof(TombStone), "Setup")]
		[HarmonyPrefix]
		public static void TombStone_Setup_Prefix(TombStone __instance, string ownerName, long ownerUID)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Grave", $"owner:{ownerName}({ownerUID})"));
			}
		}
	}
	[HarmonyPatch]
	public static class BedPatches
	{
		[HarmonyPatch(typeof(Bed), "Interact")]
		[HarmonyPostfix]
		public static void Bed_Interact_Postfix(Bed __instance, Humanoid human, bool repeat, bool alt, ref bool __result)
		{
			if (!((Object)(object)human != (Object)(object)Player.m_localPlayer) && __result)
			{
				StatsTracker.Instance.RecordSleep();
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Sleep"));
			}
		}
	}
	[HarmonyPatch]
	public static class HarmonyPatches
	{
		private static readonly Dictionary<Character, HitData> _lastHitCache;

		private static readonly FieldInfo _nviewField;

		private static readonly FieldInfo _lastHitField;

		private static readonly MethodInfo _memberwiseClone;

		private static readonly Dictionary<string, string> TrophyKeys;

		private static readonly Dictionary<string, string> InternalNameToDisplayName;

		private static readonly Dictionary<string, string> NormalizedNameToKey;

		private static ZNetView GetNView(Character character)
		{
			try
			{
				object? obj = _nviewField?.GetValue(character);
				return (ZNetView)((obj is ZNetView) ? obj : null);
			}
			catch
			{
				return null;
			}
		}

		private static bool IsLocalPlayer(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return (Object)(object)player == (Object)(object)Player.m_localPlayer;
			}
			return false;
		}

		private static string GetDominantElement(HitData hit)
		{
			//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_0014: 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_001d: 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_0033: 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_0049: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			if (hit == null)
			{
				return null;
			}
			DamageTypes damage = hit.m_damage;
			string result = null;
			float num = 0f;
			if (damage.m_fire > num)
			{
				num = damage.m_fire;
				result = "Fire";
			}
			if (damage.m_frost > num)
			{
				num = damage.m_frost;
				result = "Frost";
			}
			if (damage.m_lightning > num)
			{
				num = damage.m_lightning;
				result = "Lightning";
			}
			if (damage.m_poison > num)
			{
				num = damage.m_poison;
				result = "Poison";
			}
			if (damage.m_spirit > num)
			{
				num = damage.m_spirit;
				result = "Spirit";
			}
			return result;
		}

		private static int GetTrophyCount(string mobName)
		{
			if (StatsTracker.Instance?.sessionStats?.trophies == null)
			{
				return 0;
			}
			if (TrophyKeys.TryGetValue(mobName, out string value) && StatsTracker.Instance.sessionStats.trophies.TryGetValue(value, out var value2))
			{
				return value2;
			}
			return 0;
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		[HarmonyPostfix]
		public static void Player_OnSpawned_Postfix(Player __instance)
		{
			if (IsLocalPlayer(__instance))
			{
				StatsTracker.Instance.StartTracking(__instance);
				TimerOverlay.Instance.StartTimer();
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Spawned", ActivityLogger.FormatPlayer()));
			}
		}

		[HarmonyPatch(typeof(Player), "TeleportTo")]
		[HarmonyPostfix]
		public static void Player_TeleportTo_Postfix(Player __instance, Vector3 pos, bool distantTeleport, ref bool __result)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (__result && IsLocalPlayer(__instance))
			{
				StatsTracker.Instance.RecordPortalUse();
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Teleport", $"distant:{distantTeleport.ToString().ToLower()} to:{pos}"));
			}
		}

		[HarmonyPatch(typeof(Player), "PlacePiece")]
		[HarmonyPostfix]
		public static void Player_PlacePiece_Postfix(Player __instance, Piece piece, Vector3 pos, Quaternion rot, bool doAttack)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (IsLocalPlayer(__instance) && !((Object)(object)piece == (Object)null))
			{
				StatsTracker.Instance.RecordBuilding(((Object)piece).name);
				ActivityLogger.SendEvent(ActivityLogger.FormatEventPosition("Place", pos, ((Object)piece).name));
			}
		}

		[HarmonyPatch(typeof(Player), "OnDeath")]
		[HarmonyPrefix]
		public static void Player_OnDeath_Prefix(Player __instance)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (IsLocalPlayer(__instance))
			{
				string deathCause = StatsTracker.GetDeathCause(__instance);
				string lastDeathAttacker = StatsTracker.Instance.lastDeathAttacker;
				StatsTracker.Instance.RecordDeath(((Component)__instance).transform.position, deathCause, lastDeathAttacker);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Dead", "cause:" + deathCause + " attacker:" + lastDeathAttacker));
			}
		}

		[HarmonyPatch(typeof(TombStone), "Setup")]
		[HarmonyPostfix]
		public static void TombStone_Setup_Postfix(TombStone __instance)
		{
			//IL_01a3: 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)
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			try
			{
				Container component = ((Component)__instance).GetComponent<Container>();
				List<Dictionary<string, object>> list = new List<Dictionary<string, object>>();
				List<Dictionary<string, object>> list2 = new List<Dictionary<string, object>>();
				if ((Object)(object)component != (Object)null)
				{
					Inventory inventory = component.GetInventory();
					if (inventory != null)
					{
						foreach (ItemData allItem in inventory.GetAllItems())
						{
							if (allItem != null)
							{
								list.Add(new Dictionary<string, object>
								{
									["name"] = allItem.m_shared?.m_name ?? "Unknown",
									["stack"] = allItem.m_stack,
									["quality"] = allItem.m_quality
								});
							}
						}
					}
				}
				Inventory inventory2 = ((Humanoid)localPlayer).GetInventory();
				if (inventory2 != null)
				{
					foreach (ItemData allItem2 in inventory2.GetAllItems())
					{
						if (allItem2 != null)
						{
							list2.Add(new Dictionary<string, object>
							{
								["name"] = allItem2.m_shared?.m_name ?? "Unknown",
								["stack"] = allItem2.m_stack,
								["quality"] = allItem2.m_quality
							});
						}
					}
				}
				StatsTracker.Instance.RecordTombstone(new TombstoneData
				{
					tombstoneItems = list,
					remainingItems = list2,
					position = ((Component)__instance).transform.position
				});
				GCValheimStatsPlugin.BatchTriggers?.OnPlayerDeath();
			}
			catch (Exception ex)
			{
				Log.W("TombStone_Setup error: " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(Player), "ConsumeItem")]
		[HarmonyPostfix]
		public static void Player_ConsumeItem_Postfix(Player __instance, Inventory inventory, ItemData item, bool checkWorldLevel)
		{
			if (IsLocalPlayer(__instance) && item != null && item.m_shared != null)
			{
				StatsTracker.Instance.RecordFoodConsumed();
				Dictionary<string, object> parameters = new Dictionary<string, object>
				{
					["item"] = item.m_shared.m_name ?? "Unknown",
					["type"] = ((object)Unsafe.As<ItemType, ItemType>(ref item.m_shared.m_itemType)/*cast due to .constrained prefix*/).ToString(),
					["timestamp"] = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
				};
				GCValheimStatsPlugin.EventQueue?.Enqueue(EventEntry.Create("consume", parameters));
			}
		}

		[HarmonyPatch(typeof(Character), "Damage")]
		[HarmonyPostfix]
		public static void Character_Damage_Postfix(Character __instance, HitData hit)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance == (Object)null) && hit != null)
			{
				if ((Object)(object)hit.GetAttacker() != (Object)null)
				{
					_lastHitCache[__instance] = (HitData)_memberwiseClone.Invoke(hit, null);
				}
				float totalDamage = hit.GetTotalDamage();
				if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
				{
					StatsTracker.Instance.RecordDamageTaken(totalDamage);
					Character attacker = hit.GetAttacker();
					string text = (((Object)(object)attacker != (Object)null) ? ((Object)((Component)attacker).gameObject).name : "none");
					string arg = ActivityLogger.FormatDamage(hit);
					Dictionary<string, float> breakdown = new Dictionary<string, float>
					{
						["blunt"] = hit.m_damage.m_blunt,
						["slash"] = hit.m_damage.m_slash,
						["pierce"] = hit.m_damage.m_pierce,
						["fire"] = hit.m_damage.m_fire,
						["frost"] = hit.m_damage.m_frost,
						["lightning"] = hit.m_damage.m_lightning,
						["poison"] = hit.m_damage.m_poison,
						["spirit"] = hit.m_damage.m_spirit,
						["chop"] = hit.m_damage.m_chop,
						["pickaxe"] = hit.m_damage.m_pickaxe,
						["total"] = totalDamage
					};
					StatsTracker.Instance.lastDeathAttacker = text;
					StatsTracker.Instance.RecordDamageTakenFull(totalDamage, text, breakdown, ((Component)__instance).transform.position);
					ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Damaged", $"attacker:{text} health:{((Character)Player.m_localPlayer).GetHealth():0.0} {arg}"));
				}
				Character attacker2 = hit.GetAttacker();
				if ((Object)(object)attacker2 != (Object)null && (Object)(object)attacker2 == (Object)(object)Player.m_localPlayer)
				{
					StatsTracker.Instance.RecordDamageDealt(totalDamage);
					string name = ((Object)((Component)__instance).gameObject).name;
					string text2 = (__instance.IsPlayer() ? ((Object)((Component)__instance).gameObject).name : $"{name} lvl:{__instance.GetLevel()} tamed:{__instance.IsTamed().ToString().ToLower()}");
					string text3 = ActivityLogger.FormatDamage(hit);
					ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Damage", "target:" + text2 + " " + text3));
				}
			}
		}

		[HarmonyPatch(typeof(Character), "OnDeath")]
		[HarmonyPostfix]
		public static void Character_OnDeath_Postfix(Character __instance)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			if (StatsTracker.Instance == null || !StatsTracker.Instance.IsTracking)
			{
				Log.W("Character_OnDeath: tracker not ready, skip kill for " + ((Object)((Component)__instance).gameObject).name);
				return;
			}
			HitData val = null;
			if (_lastHitCache.TryGetValue(__instance, out HitData value))
			{
				val = value;
			}
			if (val == null)
			{
				try
				{
					object? obj = _lastHitField?.GetValue(__instance);
					val = (HitData)((obj is HitData) ? obj : null);
				}
				catch
				{
				}
			}
			if (val == null)
			{
				return;
			}
			Character attacker = val.GetAttacker();
			if ((Object)(object)attacker == (Object)null || (Object)(object)attacker != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			string text = GetDominantElement(val);
			if (text == null)
			{
				try
				{
					SEMan sEMan = __instance.GetSEMan();
					if (sEMan != null)
					{
						if (sEMan.HaveStatusEffect(StringExtensionMethods.GetStableHashCode("Burning")))
						{
							text = "Fire";
						}
						else if (sEMan.HaveStatusEffect(StringExtensionMethods.GetStableHashCode("Poison")))
						{
							text = "Poison";
						}
						else if (sEMan.HaveStatusEffect(StringExtensionMethods.GetStableHashCode("Frost")))
						{
							text = "Frost";
						}
						else if (sEMan.HaveStatusEffect(StringExtensionMethods.GetStableHashCode("Lightning")))
						{
							text = "Lightning";
						}
						else if (sEMan.HaveStatusEffect(StringExtensionMethods.GetStableHashCode("Spirit")))
						{
							text = "Spirit";
						}
					}
				}
				catch
				{
				}
			}
			string characterNameSafe = GetCharacterNameSafe(__instance);
			bool isBoss = __instance.IsBoss();
			bool isTamed = __instance.IsTamed();
			int level = __instance.GetLevel();
			string biomeSafe = GetBiomeSafe(__instance);
			StatsTracker.Instance.RecordEnemyKill(((Object)((Component)__instance).gameObject).name, characterNameSafe, isBoss, isTamed, level, biomeSafe, text);
			try
			{
				KillFeed.Instance.RegisterKill(characterNameSafe, level - 1);
			}
			catch
			{
			}
			_lastHitCache.Remove(__instance);
		}

		[HarmonyPatch(typeof(CharacterDrop), "GenerateDropList")]
		[HarmonyPostfix]
		public static void CharacterDrop_GenerateDropList_Postfix(CharacterDrop __instance, List<KeyValuePair<GameObject, int>> __result)
		{
			if ((Object)(object)__instance == (Object)null || __result == null || StatsTracker.Instance == null || !StatsTracker.Instance.IsTracking)
			{
				return;
			}
			try
			{
				foreach (KeyValuePair<GameObject, int> item in __result)
				{
					GameObject key = item.Key;
					if ((Object)(object)key == (Object)null)
					{
						continue;
					}
					ItemDrop component = key.GetComponent<ItemDrop>();
					if (!((Object)(object)component == (Object)null) && component.m_itemData != null && component.m_itemData.m_shared != null)
					{
						string name = component.m_itemData.m_shared.m_name;
						if (!string.IsNullOrEmpty(name) && name.IndexOf("trophy", StringComparison.OrdinalIgnoreCase) >= 0)
						{
							StatsTracker.Instance.RecordTrophy(name);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.W("GenerateDropList trophy scan error: " + ex.Message);
			}
		}

		private static string BuildKillFeedKey(string characterName, string biome, bool isBoss, bool isTamed, int level, string element)
		{
			List<string> list = new List<string>();
			list.Add(characterName ?? "Unknown");
			if (!string.IsNullOrEmpty(biome))
			{
				list.Add(biome);
			}
			if (isBoss)
			{
				list.Add("Boss");
			}
			if (isTamed)
			{
				list.Add("Tamed");
			}
			if (level > 1)
			{
				list.Add($"{level}*");
			}
			if (!string.IsNullOrEmpty(element))
			{
				list.Add(element);
			}
			return string.Join(" ", list);
		}

		static HarmonyPatches()
		{
			_lastHitCache = new Dictionary<Character, HitData>();
			_nviewField = typeof(Character).GetField("m_nview", BindingFlags.Instance | BindingFlags.NonPublic);
			_lastHitField = typeof(Character).GetField("m_lastHit", BindingFlags.Instance | BindingFlags.NonPublic);
			_memberwiseClone = typeof(object).GetMethod("MemberwiseClone", BindingFlags.Instance | BindingFlags.NonPublic);
			TrophyKeys = new Dictionary<string, string>
			{
				["Eikthyr"] = "$trophy_eikthyr",
				["The Elder"] = "$trophy_theelder",
				["Bonemass"] = "$trophy_bonemass",
				["Moder"] = "$trophy_dragonqueen",
				["Yagluth"] = "$trophy_goblinking",
				["The Queen"] = "$trophy_seekerqueen",
				["Fader"] = "$trophy_fader",
				["Boar"] = "$trophy_boar",
				["Deer"] = "$trophy_deer",
				["Greydwarf"] = "$trophy_greydwarf",
				["Greydwarf Brute"] = "$trophy_greydwarfbrute",
				["Greydwarf Shaman"] = "$trophy_greydwarfshaman",
				["Skeleton"] = "$trophy_skeleton",
				["Rancid Remains"] = "$trophy_skeletonpoison",
				["Ghost"] = "$trophy_ghost",
				["Troll"] = "$trophy_frosttroll",
				["Bear"] = "$trophy_bjorn",
				["Serpent"] = "$trophy_serpent",
				["Abomination"] = "$trophy_abomination",
				["Blob"] = "$trophy_blob",
				["Draugr"] = "$trophy_draugr",
				["Draugr Elite"] = "$trophy_draugrelite",
				["Leech"] = "$trophy_leech",
				["Surtling"] = "$trophy_surtling",
				["Wraith"] = "$trophy_wraith",
				["Kvastur"] = "$trophy_kvastur",
				["Wolf"] = "$trophy_wolf",
				["Drake"] = "$trophy_hatchling",
				["Fenring"] = "$trophy_fenring",
				["Stone Golem"] = "$trophy_sgolem",
				["Ulv"] = "$trophy_ulv",
				["Cultist"] = "$trophy_cultist",
				["Deathsquito"] = "$trophy_deathsquito",
				["Lox"] = "$trophy_lox",
				["Fuling"] = "$trophy_goblin",
				["Fuling Shaman"] = "$trophy_goblinshaman",
				["Growth"] = "$trophy_growth",
				["Seeker"] = "$trophy_seeker",
				["Seeker Soldier"] = "$trophy_seekerbrute",
				["Gjall"] = "$trophy_gjall",
				["Tick"] = "$trophy_tick",
				["Dvergr Rogue"] = "$trophy_dvergr",
				["Bonemaw"] = "$trophy_bonemawserpent",
				["Fallen Valkyrie"] = "$trophy_fallenvalkyrie",
				["Charred Warlock"] = "$trophy_charredmage",
				["Charred Warrior"] = "$trophy_charredmelee",
				["Charred Marksman"] = "$trophy_charredarcher",
				["Volture"] = "$trophy_volture",
				["Morgen"] = "$trophy_morgen",
				["Asksvin"] = "$trophy_asksvin",
				["Hare"] = "$trophy_hare",
				["Brenna"] = "$trophy_brenna",
				["Geirrhafa"] = "$trophy_geirrhafa",
				["Lord Reto"] = "$trophy_lordreto",
				["Neck"] = "$trophy_neck",
				["Greyling"] = "$trophy_greyling",
				["Oozer"] = "$trophy_blobelite",
				["Bat"] = "$trophy_bat",
				["Vile"] = "$trophy_vile",
				["Fuling Berserker"] = "$trophy_goblinbrute",
				["Seeker Brood"] = "$trophy_seekerbrood",
				["Dvergr Mage"] = "$trophy_dvergrmage",
				["Lava Blob"] = "$trophy_lavablob",
				["Charred Twitcher"] = "$trophy_charredtwitcher",
				["Zil"] = "$trophy_shamanbro",
				["Thunder"] = "$trophy_goblinbrute_hildir"
			};
			InternalNameToDisplayName = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
			{
				["goblin"] = "Fuling",
				["goblinbrute"] = "Fuling Berserker",
				["goblinshaman"] = "Fuling Shaman",
				["goblinking"] = "Yagluth",
				["hatchling"] = "Drake",
				["dragon"] = "Moder",
				["bjorn"] = "Bear",
				["skeletonpoison"] = "Rancid Remains",
				["skeletonhildir"] = "Brenna",
				["skeletonfire"] = "Brenna",
				["gdking"] = "The Elder",
				["seekerbrute"] = "Seeker Soldier",
				["seekerqueen"] = "The Queen",
				["seekerbrood"] = "Seeker Brood",
				["babyseeker"] = "Seeker Brood",
				["charred_mage"] = "Charred Warlock",
				["charred_melee"] = "Charred Warrior",
				["charred_archer"] = "Charred Marksman",
				["blobelite"] = "Oozer",
				["blobtar"] = "Growth",
				["bloblava"] = "Lava Blob",
				["fenringcultist"] = "Cultist",
				["fenringcultist_hildir"] = "Geirrhafa",
				["dverger"] = "Dvergr Rogue",
				["dvergr"] = "Dvergr Rogue",
				["dverger_mage"] = "Dvergr Mage",
				["bonemawserpent"] = "Bonemaw",
				["unbjorn"] = "Vile",
				["ghost"] = "Ghost",
				["bonemass"] = "Bonemass",
				["bat"] = "Bat",
				["ulv"] = "Ulv",
				["goblinshaman_hildir"] = "Zil",
				["goblin_hildir"] = "Zil",
				["goblinbrute_hildir"] = "Thunder"
			};
			NormalizedNameToKey = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			string[] orderedNames = MobIcons.OrderedNames;
			foreach (string text in orderedNames)
			{
				string key = NormalizeForMatch(text);
				if (!NormalizedNameToKey.ContainsKey(key))
				{
					NormalizedNameToKey[key] = text;
				}
			}
		}

		private static string NormalizeForMatch(string s)
		{
			StringBuilder stringBuilder = new StringBuilder(s.Length);
			foreach (char c in s)
			{
				if (char.IsLetterOrDigit(c))
				{
					stringBuilder.Append(char.ToLowerInvariant(c));
				}
			}
			return stringBuilder.ToString();
		}

		private static string MatchIconName(string raw)
		{
			string key = NormalizeForMatch(raw);
			if (NormalizedNameToKey.TryGetValue(key, out string value))
			{
				return value;
			}
			return raw;
		}

		private static string GetCharacterNameSafe(Character character)
		{
			try
			{
				FieldInfo field = ((object)character).GetType().GetField("m_name", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null && field.GetValue(character) is string text && !string.IsNullOrEmpty(text))
				{
					string text2 = text.Replace("(Clone)", "").Trim();
					if (!string.IsNullOrEmpty(text2))
					{
						string raw;
						if (text2.StartsWith("$"))
						{
							string text3 = ResolveLocalization(text2);
							raw = ((!string.IsNullOrEmpty(text3)) ? text3 : text2);
						}
						else
						{
							raw = text2;
						}
						return MatchIconName(raw);
					}
				}
			}
			catch (Exception ex)
			{
				Log.W("GetCharacterName error: " + ex.Message);
			}
			string text4 = ((Object)((Component)character).gameObject).name;
			int num = text4.IndexOf('(');
			if (num > 0)
			{
				text4 = text4.Substring(0, num).Trim();
			}
			string key = text4.ToLowerInvariant().Replace(" ", "");
			if (InternalNameToDisplayName.TryGetValue(key, out string value))
			{
				return value;
			}
			string key2 = NormalizeForMatch(text4);
			if (InternalNameToDisplayName.TryGetValue(key2, out value))
			{
				return value;
			}
			return text4;
		}

		private static string ResolveLocalization(string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				return key;
			}
			if (key.StartsWith("$"))
			{
				string text = key.Substring(1);
				if (text.StartsWith("enemy_"))
				{
					string text2 = text.Substring(6);
					if (InternalNameToDisplayName.TryGetValue(text2, out string value))
					{
						return value;
					}
					string text3 = NormalizeForMatch(text2);
					if (text3 != text2 && InternalNameToDisplayName.TryGetValue(text3, out value))
					{
						return value;
					}
				}
				if (InternalNameToDisplayName.TryGetValue(text, out string value2))
				{
					return value2;
				}
				string text4 = NormalizeForMatch(text);
				if (text4 != text && InternalNameToDisplayName.TryGetValue(text4, out value2))
				{
					return value2;
				}
				text = text.Replace("_", " ");
				if (text.StartsWith("enemy "))
				{
					text = text.Substring(6);
				}
				else if (text.StartsWith("item "))
				{
					text = text.Substring(5);
				}
				else if (text.StartsWith("trophy "))
				{
					text = text.Substring(7);
				}
				else if (text.StartsWith("piece "))
				{
					text = text.Substring(6);
				}
				string[] array = text.Split(new char[1] { ' ' });
				for (int i = 0; i < array.Length; i++)
				{
					if (array[i].Length > 0)
					{
						array[i] = char.ToUpper(array[i][0]) + array[i].Substring(1);
					}
				}
				return string.Join(" ", array);
			}
			return key;
		}

		private static string GetBiomeSafe(Character character)
		{
			//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_0162: 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_0140: 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)
			try
			{
				Vector3 position = ((Component)character).transform.position;
				Type type = typeof(ZNet).Assembly.GetType("Heightmap");
				if (type != null)
				{
					MethodInfo method = type.GetMethod("GetHeightmap", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(Vector3) }, null);
					if (method != null)
					{
						object obj = method.Invoke(null, new object[1] { position });
						if (obj != null)
						{
							MethodInfo method2 = type.GetMethod("GetBiome", BindingFlags.Instance | BindingFlags.Public, null, new Type[3]
							{
								typeof(Vector3),
								typeof(float),
								typeof(bool)
							}, null);
							if (method2 != null)
							{
								object obj2 = method2.Invoke(obj, new object[3] { position, 0f, false });
								if (obj2 != null)
								{
									return obj2.ToString();
								}
							}
						}
					}
					MethodInfo method3 = type.GetMethod("FindBiome", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(Vector3) }, null);
					if (method3 != null)
					{
						object obj3 = method3.Invoke(null, new object[1] { position });
						if (obj3 != null)
						{
							return obj3.ToString();
						}
					}
				}
				Log.W($"No biome method found, pos={position}");
			}
			catch (Exception ex)
			{
				Log.W("GetBiome error: " + ex.Message);
			}
			return "Unknown";
		}

		[HarmonyPatch(typeof(MineRock5), "Damage")]
		[HarmonyPrefix]
		public static void MineRock5_Damage_Prefix(MineRock5 __instance, HitData hit)
		{
			if (!((Object)(object)__instance == (Object)null) && hit != null)
			{
				Character attacker = hit.GetAttacker();
				if ((Object)(object)attacker != (Object)null && (Object)(object)attacker == (Object)(object)Player.m_localPlayer)
				{
					StatsTracker.Instance.RecordMining(((Object)((Component)__instance).gameObject).name);
					string text = ActivityLogger.FormatDamage(hit);
					ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Damage", "target:" + ((Object)((Component)__instance).gameObject).name + " " + text));
				}
			}
		}

		[HarmonyPatch(typeof(TreeBase), "Damage")]
		[HarmonyPrefix]
		public static void TreeBase_Damage_Prefix(TreeBase __instance, ref HitData hit)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				Character attacker = hit.GetAttacker();
				if ((Object)(object)attacker != (Object)null && (Object)(object)attacker == (Object)(object)Player.m_localPlayer)
				{
					StatsTracker.Instance.RecordChopping(((Object)((Component)__instance).gameObject).name);
					string text = ActivityLogger.FormatDamage(hit);
					ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Damage", "target:" + ((Object)((Component)__instance).gameObject).name + " " + text));
				}
			}
		}

		[HarmonyPatch(typeof(TreeLog), "Damage")]
		[HarmonyPrefix]
		public static void TreeLog_Damage_Prefix(TreeLog __instance, ref HitData hit)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				Character attacker = hit.GetAttacker();
				if ((Object)(object)attacker != (Object)null && (Object)(object)attacker == (Object)(object)Player.m_localPlayer)
				{
					StatsTracker.Instance.RecordChopping(((Object)((Component)__instance).gameObject).name);
					string text = ActivityLogger.FormatDamage(hit);
					ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Damage", "target:" + ((Object)((Component)__instance).gameObject).name + " " + text));
				}
			}
		}

		[HarmonyPatch(typeof(Pickable), "Interact")]
		[HarmonyPostfix]
		public static void Pickable_Interact_Postfix(Pickable __instance, Humanoid character, bool repeat, bool alt, ref bool __result)
		{
			if (!((Object)(object)__instance == (Object)null) && __result && !((Object)(object)character != (Object)(object)Player.m_localPlayer))
			{
				StatsTracker.Instance.RecordPickup(((Object)((Component)__instance).gameObject).name);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Pickup", ((Object)((Component)__instance).gameObject).name));
			}
		}

		[HarmonyPatch(typeof(Fish), "Interact")]
		[HarmonyPostfix]
		public static void Fish_Interact_Postfix(Fish __instance, Humanoid character, bool repeat, bool alt, ref bool __result)
		{
			if (!((Object)(object)__instance == (Object)null) && __result && !((Object)(object)character != (Object)(object)Player.m_localPlayer))
			{
				StatsTracker.Instance.RecordFishing(((Object)((Component)__instance).gameObject).name);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Pickup", ((Object)((Component)__instance).gameObject).name));
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "Interact")]
		[HarmonyPostfix]
		public static void TeleportWorld_Interact_Postfix(TeleportWorld __instance, Humanoid human, bool hold, bool alt, ref bool __result)
		{
			if (!((Object)(object)__instance == (Object)null) && __result && !((Object)(object)human != (Object)(object)Player.m_localPlayer))
			{
				StatsTracker.Instance.RecordPortalUse();
				string text = __instance.GetText();
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Interact", ((Object)((Component)__instance).gameObject).name + " result:" + __result.ToString().ToLower() + " info:" + text));
			}
		}

		[HarmonyPatch(typeof(Tameable), "Interact")]
		[HarmonyPostfix]
		public static void Tameable_Interact_Postfix(Tameable __instance, Humanoid user, bool hold, bool alt, ref bool __result)
		{
			if (!((Object)(object)__instance == (Object)null) && __result && !((Object)(object)user != (Object)(object)Player.m_localPlayer))
			{
				StatsTracker.Instance.RecordTaming(((Object)((Component)__instance).gameObject).name);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Interact", ((Object)((Component)__instance).gameObject).name + " result:" + __result.ToString().ToLower()));
			}
		}

		[HarmonyPatch(typeof(Trader), "Interact")]
		[HarmonyPostfix]
		public static void Trader_Interact_Postfix(Trader __instance, Humanoid character, bool hold, bool alt, ref bool __result)
		{
			if (!((Object)(object)__instance == (Object)null) && __result && !((Object)(object)character != (Object)(object)Player.m_localPlayer))
			{
				StatsTracker.Instance.RecordTrade(__instance.m_name);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Interact", ((Object)((Component)__instance).gameObject).name + " result:" + __result.ToString().ToLower() + " info:" + __instance.m_name));
			}
		}

		[HarmonyPatch(typeof(Minimap), "AddPin")]
		[HarmonyPostfix]
		public unsafe static void Minimap_AddPin_Postfix(Minimap __instance, Vector3 pos, PinType type, string name, bool save, bool isChecked)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance == (Object)null))
			{
				StatsTracker.Instance.RecordMapPin(((object)(*(PinType*)(&type))/*cast due to .constrained prefix*/).ToString());
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Ping", $"type:{type} name:{name}"));
			}
		}

		[HarmonyPatch(typeof(ConsoleCommand), "RunAction")]
		[HarmonyPostfix]
		public static void ConsoleCommand_RunAction_Postfix(ConsoleCommand __instance, ConsoleEventArgs args)
		{
			if (__instance != null && args != null)
			{
				string parameters = ((args.Length > 0) ? args[0] : "");
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Command", parameters));
			}
		}

		[HarmonyPatch(typeof(Skills), "RaiseSkill")]
		[HarmonyPostfix]
		public unsafe static void Skills_RaiseSkill_Postfix(Skills __instance, SkillType skillType, float factor)
		{
			//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)
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)/*isinst with value type is only supported in some contexts*/ != (Object)(object)__instance)
			{
				return;
			}
			List<Skill> skillList = __instance.GetSkillList();
			if (skillList == null)
			{
				return;
			}
			foreach (Skill item in skillList)
			{
				if (item != null && item.m_info.m_skill == skillType && item.m_level > 0f)
				{
					StatsTracker.Instance.RecordSkillLevelUp(((object)(*(SkillType*)(&skillType))/*cast due to .constrained prefix*/).ToString());
					break;
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		public static void ZNet_Disconnect_Prefix(ZNet __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				GCValheimStatsPlugin.SendFinalStats();
			}
		}
	}
	[HarmonyPatch]
	public static class HumanoidPatches
	{
		[HarmonyPatch(typeof(Humanoid), "EquipItem")]
		[HarmonyPrefix]
		public static void Humanoid_EquipItem_Prefix(Humanoid __instance, ItemData item, bool triggerEquipEffects)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && item != null)
			{
				string parameters = ActivityLogger.FormatItem(item);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Equip", parameters));
			}
		}

		[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
		[HarmonyPrefix]
		public static void Humanoid_UnequipItem_Prefix(Humanoid __instance, ItemData item, bool triggerEquipEffects)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && item != null)
			{
				string parameters = ActivityLogger.FormatItem(item);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Unequip", parameters));
			}
		}

		[HarmonyPatch(typeof(Humanoid), "DropItem")]
		[HarmonyPrefix]
		public static void Humanoid_DropItem_Prefix(Humanoid __instance, ItemData item, int amount)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && item != null)
			{
				string text = ActivityLogger.FormatItem(item, amount);
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Drop", "from:inventory item:" + text));
			}
		}
	}
	[HarmonyPatch]
	public static class InventoryPatches
	{
		[HarmonyPatch(typeof(Inventory), "MoveAll")]
		[HarmonyPrefix]
		public static void Inventory_MoveAll_Prefix(Inventory __instance, Inventory fromInventory)
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
				if (__instance == inventory || fromInventory == inventory)
				{
					ActivityLogger.SendEvent(ActivityLogger.FormatEvent("MoveAll", "from:" + fromInventory.GetName() + " to:" + __instance.GetName()));
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "StackAll")]
		[HarmonyPrefix]
		public static void Inventory_StackAll_Prefix(Inventory __instance, Inventory fromInventory)
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
				if (__instance == inventory || fromInventory == inventory)
				{
					ActivityLogger.SendEvent(ActivityLogger.FormatEvent("StackAll", "from:" + fromInventory.GetName() + " to:" + __instance.GetName()));
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "RemoveItem", new Type[]
		{
			typeof(ItemData),
			typeof(int)
		})]
		[HarmonyPrefix]
		public static void Inventory_RemoveItem_Prefix(Inventory __instance, ItemData item, int amount)
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
				if (__instance == inventory && item != null)
				{
					string text = ActivityLogger.FormatItem(item, amount);
					ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Remove", "from:inventory item:" + text));
				}
			}
		}
	}
	[HarmonyPatch]
	public static class StaggerPatches
	{
		[HarmonyPatch(typeof(Character), "Stagger")]
		[HarmonyPrefix]
		public static void Character_Stagger_Prefix(Character __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Staggered", "player:" + ((Object)((Component)__instance).gameObject).name));
			}
		}

		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		[HarmonyPostfix]
		public static void Character_RPC_Damage_Postfix(Character __instance, HitData hit)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance == (Object)(object)Player.m_localPlayer) && hit != null)
			{
				Character attacker = hit.GetAttacker();
				if (!((Object)(object)attacker == (Object)null) && !((Object)(object)attacker != (Object)(object)Player.m_localPlayer) && __instance.IsStaggering())
				{
					float totalDamage = hit.GetTotalDamage();
					ActivityLogger.SendEvent(ActivityLogger.FormatEvent("Stagger", $"target:{((Object)((Component)__instance).gameObject).name} lvl:{__instance.GetLevel()} damage:{totalDamage:0.0}"));
				}
			}
		}
	}
}
namespace GCValheimStats.Networking
{
	public class BatchSender
	{
		private readonly QueueStorage _storage;

		private readonly StatsHttpClient _httpClient;

		private readonly string _serverUrl;

		public event Action<string> OnBatchSent;

		public event Action<string, string> OnSendError;

		public BatchSender(QueueStorage storage, StatsHttpClient httpClient, string serverUrl)
		{
			_storage = storage;
			_httpClient = httpClient;
			_serverUrl = serverUrl;
		}

		public async Task<int> SendAllPending(byte[] aesKey, byte[] hmacKey)
		{
			List<BatchData> list = _storage.LoadAllPending(aesKey, hmacKey);
			int sent = 0;
			foreach (BatchData batch in list)
			{
				if (await SendBatchNow(batch, hmacKey))
				{
					_storage.DeleteBatch(batch.BatchId);
					this.OnBatchSent?.Invoke(batch.BatchId);
					sent++;
				}
			}
			return sent;
		}

		public async Task<bool> SendBatchNow(BatchData batch, byte[] hmacKey)
		{
			var (flag, text) = await _httpClient.SendBatch(_serverUrl, batch, hmacKey);
			if (!flag)
			{
				Log.W("SendBatch failed for " + batch.BatchId + ": " + text);
				this.OnSendError?.Invoke(batch.BatchId, text);
			}
			return flag;
		}

		public int SendAllPendingSync(byte[] aesKey, byte[] hmacKey)
		{
			List<BatchData> list = _storage.LoadAllPending(aesKey, hmacKey);
			int num = 0;
			HttpWebResponse httpWebResponse = default(HttpWebResponse);
			foreach (BatchData item in list)
			{
				try
				{
					string s = item.ToJson();
					byte[] bytes = Encoding.UTF8.GetBytes(s);
					string text = CryptoHelper.ComputeHmac(bytes, hmacKey);
					using WebClient webClient = new WebClient();
					webClient.Headers[HttpRequestHeader.ContentType] = "application/json";
					webClient.Headers["X-GCValStats-HMAC"] = "sha256:" + text;
					webClient.UploadData(_serverUrl, "POST", bytes);
					_storage.DeleteBatch(item.BatchId);
					num++;
				}
				catch (WebException ex) when (((Func<bool>)delegate
				{
					// Could not convert BlockContainer to single expression
					httpWebResponse = ex.Response as HttpWebResponse;
					return httpWebResponse != null;
				}).Invoke())
				{
					string text2 = new StreamReader(httpWebResponse.GetResponseStream()).ReadToEnd();
					Log.W($"Sync send failed for {item.BatchId}: HTTP {(int)httpWebResponse.StatusCode} {httpWebResponse.StatusDescription} — {text2}");
				}
				catch (Exception ex2)
				{
					Log.W("Sync send failed for " + item.BatchId + ": " + ex2.Message);
				}
			}
			return num;
		}
	}
	public class StatsHttpClient : IDisposable
	{
		private readonly HttpClient _client;

		public StatsHttpClient()
		{
			//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_0025: Expected O, but got Unknown
			_client = new HttpClient
			{
				Timeout = TimeSpan.FromSeconds(5.0)
			};
		}

		public async Task<bool> PingServer(string url, string steamId = null)
		{
			_ = 1;
			try
			{
				string text = url.TrimEnd(new char[1] { '/' }) + "/ping";
				if (!string.IsNullOrEmpty(steamId))
				{
					new Dictionary<string, string>().Add("steam_id", steamId);
					StringContent val = new StringContent("{\"steam_id\":\"" + steamId + "\"}", Encoding.UTF8, "application/json");
					return (await _client.PostAsync(text, (HttpContent)(object)val)).IsSuccessStatusCode;
				}
				return (await _client.GetAsync(text)).IsSuccessStatusCode;
			}
			catch
			{
				return false;
			}
		}

		public async Task<(bool success, string error)> SendBatch(string url, BatchData batch, byte[] hmacKey)
		{
			_ = 1;
			try
			{
				string text = batch.ToJson();
				string text2 = CryptoHelper.ComputeHmac(Encoding.UTF8.GetBytes(text), hmacKey);
				StringContent val = new StringContent(text, Encoding.UTF8, "application/json");
				((HttpHeaders)((HttpContent)val).Headers).Add("X-GCValStats-HMAC", "sha256:" + text2);
				HttpResponseMessage response = await _client.PostAsync(url, (HttpContent)(object)val);
				if (response.IsSuccessStatusCode)
				{
					return (success: true, error: null);
				}
				string arg = await response.Content.ReadAsStringAsync();
				return (success: false, error: $"HTTP {(int)response.StatusCode}: {arg}");
			}
			catch (TaskCanceledException)
			{
				return (success: false, error: "Request timeout");
			}
			catch (HttpRequestException ex2)
			{
				HttpRequestException ex3 = ex2;
				return (success: false, error: "Network error: " + ((Exception)(object)ex3).Message);
			}
			catch (Exception ex4)
			{
				return (success: false, error: ex4.Message);
			}
		}

		public void Dispose()
		{
			HttpClient client = _client;
			if (client != null)
			{
				((HttpMessageInvoker)client).Dispose();
			}
		}
	}
}
namespace GCValheimStats.Collect
{
	public class BatchTriggers
	{
		private readonly EventQueue _queue;

		private readonly BatchBuilder _builder;

		private readonly QueueStorage _storage;

		private readonly BatchSender _sender;

		private readonly SessionManager _session;

		private readonly StatsHttpClient _httpClient;

		private readonly string _serverUrl;

		private readonly byte[] _aesKey;

		private readonly byte[] _hmacKey;

		private float _timer;

		private float _pingTimer;

		private float _statsTimer;

		private bool _wasPaused;

		private const float TIMER_INTERVAL = 5f;

		private const float PING_INTERVAL = 30f;

		private const float STATS_INTERVAL = 60f;

		private bool _isSending;

		private bool _worldInfoSent;

		private bool _serverOnline;

		public BatchTriggers(EventQueue queue, BatchBuilder builder, QueueStorage storage, BatchSender sender, SessionManager session, StatsHttpClient httpClient, string serverUrl, byte[] aesKey, byte[] hmacKey)
		{
			_queue = queue;
			_builder = builder;
			_storage = storage;
			_sender = sender;
			_session = session;
			_httpClient = httpClient;
			_serverUrl = serverUrl;
			_aesKey = aesKey;
			_hmacKey = hmacKey;
			_sender.OnBatchSent += delegate
			{
			};
			_sender.OnSendError += delegate(string id, string err)
			{
				Log.W("Batch send error: " + id + " — " + err);
			};
		}

		public void Update()
		{
			if (!_session.IsActive || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			if (!_worldInfoSent && (Object)(object)ZNet.instance != (Object)null)
			{
				_worldInfoSent = true;
				SendWorldInfo();
			}
			_timer += Time.unscaledDeltaTime;
			if (_timer >= 5f)
			{
				_timer = 0f;
				BuildAndStore();
				if (_serverOnline)
				{
					FlushPending();
				}
			}
			_statsTimer += Time.unscaledDeltaTime;
			if (_statsTimer >= 60f)
			{
				_statsTimer = 0f;
				if (!IsPaused())
				{
					SendPlayerStats();
				}
			}
			_pingTimer += Time.unscaledDeltaTime;
			if (_pingTimer >= 30f)
			{
				_pingTimer = 0f;
				SendPing();
			}
			bool flag = IsPaused();
			if (flag && !_wasPaused)
			{
				EventEntry entry = EventEntry.Create("pause", new Dictionary<string, object> { ["timestamp"] = DateTimeOffset.UtcNow.ToUnixTimeSeconds() });
				_queue.Enqueue(entry);
				BuildAndStore();
				if (_serverOnline)
				{
					FlushPending();
				}
			}
			else if (!flag && _wasPaused)
			{
				EventEntry entry2 = EventEntry.Create("resume", new Dictionary<string, object> { ["timestamp"] = DateTimeOffset.UtcNow.ToUnixTimeSeconds() });
				_queue.Enqueue(entry2);
				SendPlayerStats();
				BuildAndStore();
				if (_serverOnline)
				{
					FlushPending();
				}
			}
			_wasPaused = flag;
		}

		public void OnPlayerDeath()
		{
			//IL_0065: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				string deathCause = StatsTracker.GetDeathCause(localPlayer);
				string lastDeathAttacker = StatsTracker.Instance.lastDeathAttacker;
				TombstoneData lastTombstoneData = StatsTracker.Instance.lastTombstoneData;
				Dictionary<string, object> dictionary = new Dictionary<string, object>();
				dictionary["cause"] = deathCause;
				dictionary["attacker"] = lastDeathAttacker;
				dictionary["position"] = new float[3]
				{
					((Component)localPlayer).transform.position.x,
					((Component)localPlayer).transform.position.y,
					((Component)localPlayer).transform.position.z
				};
				dictionary["health_before"] = ((Character)localPlayer).GetHealth();
				dictionary["timestamp"] = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
				Dictionary<string, object> dictionary2 = dictionary;
				if (lastTombstoneData != null)
				{
					dictionary2["tombstone_items"] = lastTombstoneData.tombstoneItems;
					dictionary2["player_items"] = lastTombstoneData.remainingItems;
				}
				EventEntry entry = EventEntry.Create("death", dictionary2);
				_queue.Enqueue(entry);
			}
			SendPlayerStats();
			BuildAndStore();
		}

		public void OnWorldExit()
		{
			SendWorldExit();
			_worldInfoSent = false;
			BuildAndStore();
			FlushPending();
		}

		public void OnConsoleSend()
		{
			BuildAndStore();
			FlushPending();
		}

		public void SendInventorySnapshot()
		{
			try
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsDead())
				{
					return;
				}
				Inventory inventory = ((Humanoid)localPlayer).GetInventory();
				if (inventory == null)
				{
					return;
				}
				List<Dictionary<string, object>> list = new List<Dictionary<string, object>>();
				foreach (ItemData allItem in inventory.GetAllItems())
				{
					if (allItem != null && allItem.m_shared != null)
					{
						list.Add(new Dictionary<string, object>
						{
							["name"] = allItem.m_shared.m_name,
							["stack"] = allItem.m_stack,
							["quality"] = allItem.m_quality,
							["durability"] = allItem.m_durability,
							["weight"] = allItem.m_shared.m_weight
						});
					}
				}
				Dictionary<string, object> parameters = new Dictionary<string, object>
				{
					["items"] = list,
					["total_weight"] = inventory.GetTotalWeight(),
					["slot_count"] = inventory.GetWidth() * inventory.GetHeight(),
					["free_slots"] = inventory.GetWidth() * inventory.GetHeight() - inventory.NrOfItems(),
					["timestamp"] = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
				};
				EventEntry entry = EventEntry.Create("inventory_snapshot", parameters);
				_queue.Enqueue(entry);
			}
			catch (Exception ex)
			{
				Log.E("SendInventorySnapshot error: " + ex.Message);
			}
		}

		public void OnApplicationQuit()
		{
			BuildAndStore();
			if (_serverOnline)
			{
				FlushPendingSync();
			}
		}

		private void SendWorldInfo()
		{
			try
			{
				Dictionary<string, object> parameters = WorldStatsCollector.CollectWorldInfo();
				EventEntry entry = EventEntry.Create("WorldInfo", parameters);
				_queue.Enqueue(entry);
				SendPlayerStats();
				BuildAndStore();
				if (_serverOnline)
				{
					FlushPendingSync();
				}
			}
			catch (Exception ex)
			{
				Log.E("SendWorldInfo error: " + ex.Message);
			}
		}

		private void SendWorldExit()
		{
			try
			{
				SendPlayerStats();
				Dictionary<string, object> parameters = new Dictionary<string, object>
				{
					["timestamp"] = DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
					["world_name"] = GetWorldNameSafe(),
					["world_seed"] = GetWorldSeedSafe()
				};
				EventEntry entry = EventEntry.Create("WorldExit", parameters);
				_queue.Enqueue(entry);
			}
			catch (Exception ex)
			{
				Log.E("SendWorldExit error: " + ex.Message);
			}
		}

		public void SendPlayerStats()
		{
			try
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null))
				{
					StatsTracker.Instance.SavePersistentData();
					Dictionary<string, object> dictionary = EnhancedStatsCollector.CollectFullPlayerStats(localPlayer);
					if (dictionary.Count != 0)
					{
						EventEntry entry = EventEntry.Create("PlayerStats", dictionary);
						_queue.Enqueue(entry);
					}
				}
			}
			catch (Exception ex)
			{
				Log.E("SendPlayerStats error: " + ex.Message);
			}
		}

		private static string GetWorldNameSafe()
		{
			try
			{
				ZNet instance = ZNet.instance;
				return ((instance != null) ? instance.GetWorldName() : null) ?? "Unknown";
			}
			catch
			{
				return "Unknown";
			}
		}

		private static string GetWorldSeedSafe()
		{
			try
			{
				Type type = typeof(ZNet).Assembly.GetType("WorldGenerator");
				if (type == null)
				{
					return "Unknown";
				}
				FieldInfo field = type.GetField("m_instance", BindingFlags.Static | BindingFlags.NonPublic);
				if (field == null)
				{
					return "Unknown";
				}
				object value = field.GetValue(null);
				if (value == null)
				{
					return "Unknown";
				}
				FieldInfo field2 = type.GetField("m_world", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field2 == null)
				{
					return "Unknown";
				}
				object value2 = field2.GetValue(value);
				if (value2 == null)
				{
					return "Unknown";
				}
				object obj = value2.GetType().GetField("m_seed")?.GetValue(value2);
				if (obj != null)
				{
					return obj.ToString();
				}
			}
			catch
			{
			}
			return "Unknown";
		}

		private void BuildAndStore()
		{
			BatchData batchData = _builder.BuildBatch();
			if (batchData != null)
			{
				_storage.SaveBatch(batchData, _aesKey, _hmacKey);
				UpdateOverlayCount();
			}
		}

		private void UpdateOverlayCount()
		{
			try
			{
				if ((Object)(object)StatsOverlay.Instance != (Object)null)
				{
					StatsOverlay.Instance.SetUnsentCount(_storage.GetPendingCount());
				}
			}
			catch
			{
			}
		}

		private async void FlushPending()
		{
			if (_isSending)
			{
				return;
			}
			_isSending = true;
			try
			{
				while (true)
				{
					List<BatchData> list = _storage.LoadAllPending(_aesKey, _hmacKey);
					if (list.Count != 0)
					{
						BatchData batch = list[0];
						var (flag, text) = await _httpClient.SendBatch(_serverUrl, batch, _hmacKey);
						if (flag || (text != null && text.Contains("409")))
						{
							_storage.DeleteBatch(batch.BatchId);
							await Task.Delay(100);
							continue;
						}
						break;
					}
					break;
				}
			}
			catch (Exception ex)
			{
				Log.E("Flush error: " + ex.Message);
			}
			finally
			{
				_isSending = false;
				UpdateOverlayCount();
			}
		}

		private void FlushPendingSync()
		{
			try
			{
				_sender.SendAllPendingSync(_aesKey, _hmacKey);
				_ = 0;
			}
			catch (Exception ex)
			{
				Log.E("Sync flush error: " + ex.Message);
			}
		}

		private static bool IsPaused()
		{
			return Time.timeScale == 0f;
		}

		private async void SendPing()
		{
			try
			{
				if (_httpClient != null && !string.IsNullOrEmpty(_serverUrl))
				{
					string text = _serverUrl;
					int num = text.LastIndexOf('/');
					if (num > 0)
					{
						text = text.Substring(0, num);
					}
					string text2 = (((Object)(object)GCValheimStatsPlugin.Instance != (Object)null) ? GCValheimStatsPlugin.Instance.SteamId.ToString() : "0");
					if (!(text2 == "0"))
					{
						_serverOnline = await _httpClient.PingServer(text, text2);
					}
				}
			}
			catch (Exception ex)
			{
				_serverOnline = false;
				Log.W("In-world ping error: " + ex.Message);
			}
		}
	}
	public static class EnhancedStatsCollector
	{
		private static T GetPrivateField<T>(object obj, string fieldName) where T : class
		{
			if (obj == null)
			{
				return null;
			}
			return obj.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(obj) as T;
		}

		public static Dictionary<string, object> CollectFullPlayerStats(Player player)
		{
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return new Dictionary<string, object>();
			}
			StatsTracker instance = StatsTracker.Instance;
			Dictionary<string, int> value = instance?.sessionStats?.mobKills ?? new Dictionary<string, int>();
			Dictionary<string, int> value2 = instance?.lifetimeStats?.mobKills ?? new Dictionary<string, int>();
			Dictionary<string, int> value3 = instance?.sessionStats?.trophies ?? new Dictionary<string, int>();
			Dictionary<string, int> value4 = instance?.lifetimeStats?.trophies ?? new Dictionary<string, int>();
			int valueOrDefault = (instance?.sessionStats?.playTime).GetValueOrDefault();
			int valueOrDefault2 = (instance?.lifetimeStats?.playTime).GetValueOrDefault();
			Dictionary<string, object> obj = new Dictionary<string, object>
			{
				["player_id"] = player.GetPlayerID(),
				["player_name"] = player.GetPlayerName(),
				["timestamp"] = DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
				["health"] = ((Character)player).GetHealth(),
				["max_health"] = ((Character)player).GetMaxHealth(),
				["stamina"] = player.GetStamina(),
				["max_stamina"] = ((Character)player).GetMaxStamina(),
				["eitr"] = player.GetEitr(),
				["max_eitr"] = ((Character)player).GetMaxEitr(),
				["position"] = GetPosition(player),
				["current_biome"] = ((object)player.GetCurrentBiome()/*cast due to .constrained prefix*/).ToString()
			};
			Inventory inventory = ((Humanoid)player).GetInventory();
			obj["inventory_weight"] = ((inventory != null) ? inventory.GetTotalWeight() : 0f);
			obj["max_carry_weight"] = player.GetMaxCarryWeight();
			obj["equipment"] = GetEquipment(player);
			obj["active_foods"] = GetActiveFoods(player);
			obj["top_skills"] = GetTopSkills(player, 5);
			obj["historical_stats"] = GetHistoricalStats(player);
			obj["known_biomes"] = GetKnownBiomes(player);
			obj["world_seed"] = GetWorldSeed();
			obj["world_name"] = GetWorldName();
			obj["session_mob_kills"] = value;
			obj["lifetime_mob_kills"] = value2;
			obj["session_trophies"] = value3;
			obj["lifetime_trophies"] = value4;
			obj["session_play_time"] = valueOrDefault;
			obj["lifetime_play_time"] = valueOrDefault2;
			return obj;
		}

		private static float[] GetPosition(Player player)
		{
			//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_0014: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)player).transform.position;
			return new float[3] { position.x, position.y, position.z };
		}

		private static Dictionary<string, object> GetEquipment(Player player)
		{
			return new Dictionary<string, object>
			{
				["right_hand"] = GetItemInfo(GetPrivateField<ItemData>(player, "m_rightItem")),
				["left_hand"] = GetItemInfo(GetPrivateField<ItemData>(player, "m_leftItem")),
				["chest"] = GetItemInfo(GetPrivateField<ItemData>(player, "m_chestItem")),
				["legs"] = GetItemInfo(GetPrivateField<ItemData>(player, "m_legItem")),
				["helmet"] = GetItemInfo(GetPrivateField<ItemData>(player, "m_helmetItem")),
				["shoulder"] = GetItemInfo(GetPrivateField<ItemData>(player, "m_shoulderItem")),
				["utility"] = GetItemInfo(GetPrivateField<ItemData>(player, "m_utilityItem")),
				["trinket"] = GetItemInfo(GetPrivateField<ItemData>(player, "m_trinketItem")),
				["ammo"] = GetItemInfo(GetPrivateField<ItemData>(player, "m_ammoItem"))
			};
		}

		private static Dictionary<string, object> GetItemInfo(ItemData item)
		{
			if (item == null)
			{
				return null;
			}
			return new Dictionary<string, object>
			{
				["name"] = item.m_shared.m_name,
				["quality"] = item.m_quality,
				["durability"] = item.m_durability,
				["max_durability"] = item.GetMaxDurability(),
				["weight"] = item.m_shared.m_weight,
				["value"] = item.m_shared.m_value,
				["stack"] = item.m_stack,
				["max_stack"] = item.m_shared.m_maxStackSize,
				["type"] = ((object)Unsafe.As<ItemType, ItemType>(ref item.m_shared.m_itemType)/*cast due to .constrained prefix*/).ToString(),
				["skill"] = ((object)Unsafe.As<SkillType, SkillType>(ref item.m_shared.m_skillType)/*cast due to .constrained prefix*/).ToString(),
				["block_power"] = item.m_shared.m_blockPower,
				["deflection_force"] = item.m_shared.m_deflectionForce,
				["timed_block_bonus"] = item.m_shared.m_timedBlockBonus,
				["movement_modifier"] = item.m_shared.m_movementModifier,
				["jump_stamina_modifier"] = item.m_shared.m_jumpStaminaModifier,
				["attack_stamina_modifier"] = item.m_shared.m_attackStaminaModifier,
				["block_stamina_modifier"] = item.m_shared.m_blockStaminaModifier,
				["dodge_stamina_modifier"] = item.m_shared.m_dodgeStaminaModifier
			};
		}

		private static List<Dictionary<string, object>> GetActiveFoods(Player player)
		{
			List<Dictionary<string, object>> list = new List<Dictionary<string, object>>();
			IList privateField = GetPrivateField<IList>(player, "m_foods");
			if (privateField == null)
			{
				return list;
			}
			foreach (object item in privateField)
			{
				if (item == null)
				{
					continue;
				}
				try
				{
					object? obj = item.GetType().GetField("m_item")?.GetValue(item);
					ItemDrop val = (ItemDrop)((obj is ItemDrop) ? obj : null);
					float num = Convert.ToSingle(item.GetType().GetField("m_time")?.GetValue(item) ?? ((object)0f));
					float num2 = Convert.ToSingle(item.GetType().GetField("m_health")?.GetValue(item) ?? ((object)0f));
					float num3 = Convert.ToSingle(item.GetType().GetField("m_stamina")?.GetValue(item) ?? ((object)0f));
					float num4 = Convert.ToSingle(item.GetType().GetField("m_eitr")?.GetValue(item) ?? ((object)0f));
					if (val?.m_itemData?.m_shared != null)
					{
						list.Add(new Dictionary<string, object>
						{
							["name"] = val.m_itemData.m_shared.m_name,
							["remaining_time"] = num,
							["health"] = num2,
							["stamina"] = num3,
							["eitr"] = num4
						});
					}
				}
				catch
				{
				}
			}
			return list;
		}

		private static List<Dictionary<string, object>> GetTopSkills(Player player, int count)
		{
			List<Dictionary<string, object>> list = new List<Dictionary<string, object>>();
			Skills privateField = GetPrivateField<Skills>(player, "m_skills");
			if ((Object)(object)privateField == (Object)null)
			{
				return list;
			}
			List<Skill> skillList = privateField.GetSkillList();
			if (skillList == null)
			{
				return list;
			}
			foreach (Skill item in (from s in skillList
				where s != null && s.m_level > 0f
				orderby s.m_level descending
				select s).Take(count))
			{
				float level = item.m_level;
				float num = 0f;
				try
				{
					MethodInfo method = ((object)item).GetType().GetMethod("GetNextLevelRequirement");
					if (method != null)
					{
						float num2 = Convert.ToSingle(method.Invoke(item, null));
						if (num2 > 0f)
						{
							num = item.m_accumulator / num2;
						}
					}
				}
				catch
				{
				}
				list.Add(new Dictionary<string, object>
				{
					["name"] = ((object)Unsafe.As<SkillType, SkillType>(ref item.m_info.m_skill)/*cast due to .constrained prefix*/).ToString(),
					["level"] = level,
					["progress"] = num
				});
			}
			return list;
		}

		private static Dictionary<string, long> GetHistoricalStats(Player player)
		{
			Dictionary<string, long> dictionary = new Dictionary<string, long>();
			try
			{
				if ((Object)(object)Game.instance == (Object)null)
				{
					return dictionary;
				}
				PlayerProfile playerProfile = Game.instance.GetPlayerProfile();
				if (playerProfile == null)
				{
					return dictionary;
				}
				FieldInfo field = typeof(PlayerProfile).GetField("m_playerStats");
				if (field == null)
				{
					return dictionary;
				}
				object playerStats = field.GetValue(playerProfile);
				if (playerStats == null)
				{
					return dictionary;
				}
				PropertyInfo indexer = playerStats.GetType().GetProperty("Item");
				if (indexer == null)
				{
					return dictionary;
				}
				dictionary["deaths"] = GetStat(0);
				dictionary["crafts"] = GetStat(1);
				dictionary["builds"] = GetStat(2);
				dictionary["jumps"] = GetStat(3);
				dictionary["hits"] = GetStat(5);
				dictionary["kills"] = GetStat(6);
				dictionary["pvp_hits"] = GetStat(8);
				dictionary["pvp_kills"] = GetStat(9);
				dictionary["hits_taken"] = GetStat(10);
				dictionary["items_picked_up"] = GetStat(12);
				dictionary["portals"] = GetStat(15);
				dictionary["distance_total"] = GetStat(16);
				dictionary["distance_walked"] = GetStat(17);
				dictionary["distance_run"] = GetStat(18);
				dictionary["distance_sailed"] = GetStat(19);
				dictionary["distance_air"] = GetStat(20);
				dictionary["time_in_base"] = GetStat(21);
				dictionary["time_out_base"] = GetStat(22);
				dictionary["sleep_time"] = GetStat(23);
				dictionary["world_loads"] = GetStat(26);
				dictionary["trees_cut"] = GetStat(27);
				dictionary["mines"] = GetStat(37);
				dictionary["food_eaten"] = GetStat(49);
				dictionary["arrows_shot"] = GetStat(51);
				dictionary["doors_opened"] = GetStat(74);
				dictionary["bees_harvested"] = GetStat(76);
				dictionary["bosses_killed"] = GetStat(85);
				dictionary["death_undefined"] = GetStat(86);
				dictionary["death_enemy"] = GetStat(87);
				dictionary["death_player"] = GetStat(88);
				dictionary["death_fall"] = GetStat(89);
				dictionary["death_drowning"] = GetStat(90);
				dictionary["death_burning"] = GetStat(91);
				dictionary["death_freezing"] = GetStat(92);
				dictionary["death_poison"] = GetStat(93);
				dictionary["death_water"] = GetStat(94);
				dictionary["death_smoke"] = GetStat(95);
				dictionary["death_edge_of_world"] = GetStat(96);
				dictionary["death_impact"] = GetStat(97);
				dictionary["death_cart"] = GetStat(98);
				dictionary["death_tree"] = GetStat(99);
				dictionary["death_self"] = GetStat(100);
				dictionary["death_structural"] = GetStat(101);
				dictionary["death_turret"] = GetStat(102);
				dictionary["death_boat"] = GetStat(103);
				dictionary["death_stalagtite"] = GetStat(104);
				dictionary["guardian_power_use_total"] = GetStat(105);
				dictionary["power_eikthyr_use"] = GetStat(106);
				dictionary["power_elder_use"] = GetStat(107);
				dictionary["power_bonemass_use"] = GetStat(108);
				dictionary["power_moder_use"] = GetStat(109);
				dictionary["power_yagluth_use"] = GetStat(110);
				dictionary["power_queen_use"] = GetStat(111);
				dictionary["power_ashlands_use"] = GetStat(112);
				dictionary["power_deep_north_use"] = GetStat(113);
				long GetStat(int index)
				{
					try
					{
						return Convert.ToInt64(indexer.GetValue(playerStats, new object[1] { index }));
					}
					catch
					{
						return 0L;
					}
				}
			}
			catch
			{
			}
			return dictionary;
		}

		private static List<string> GetKnownBiomes(Player player)
		{
			List<string> list = new List<string>();
			try
			{
				if ((Object)(object)Game.instance == (Object)null)
				{
					return list;
				}
				PlayerProfile playerProfile = Game.instance.GetPlayerProfile();
				if (playerProfile == null)
				{
					return list;
				}
				FieldInfo field = typeof(PlayerProfile).GetField("m_knownBiome");
				if (field == null)
				{
					return list;
				}
				if (!(field.GetValue(playerProfile) is IList list2))
				{
					return list;
				}
				foreach (object item in list2)
				{
					list.Add(item.ToString());
				}
			}
			catch
			{
			}
			return list;
		}

		private static string GetWorldSeed()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return "UnknownSeed";
			}
			try
			{
				object obj = typeof(ZNet).GetField("m_world", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(ZNet.instance);
				if (obj != null)
				{
					object obj2 = obj.GetType().GetField("m_seed")?.GetValue(obj);
					if (obj2 != null)
					{
						return obj2.ToString();
					}
				}
			}
			catch
			{
			}
			return "UnknownSeed";
		}

		private static string GetWorldName()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return "UnknownWorld";
			}
			string worldName = ZNet.instance.GetWorldName();
			if (!string.IsNullOrEmpty(worldName))
			{
				return worldName;
			}
			return "UnknownWorld";
		}
	}
	public static class JsonEventFormatter
	{
		public static EventEntry FormatEvent(string eventType, Dictionary<string, object> parameters = null)
		{
			return EventEntry.Create(eventType, parameters);
		}

		public static EventEntry FormatEvent(string eventType, Vector3 position, Dictionary<string, object> parameters = null)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return EventEntry.Create(eventType, position, parameters);
		}

		public static EventEntry FormatItemEvent(string eventType, ItemData item, int amount = 1)
		{
			Dictionary<string, object> parameters = new Dictionary<string, object>
			{
				["item_name"] = item.m_shared.m_name,
				["item_quality"] = item.m_quality,
				["item_stack"] = item.m_stack,
				["item_weight"] = item.m_shared.m_weight,
				["amount"] = amount
			};
			return EventEntry.Create(eventType, parameters);
		}

		public static EventEntry FormatDamageEvent(string eventType, HitData hit)
		{
			Dictionary<string, object> parameters = new Dictionary<string, object>
			{
				["blunt"] = hit.m_damage.m_blunt,
				["slash"] = hit.m_damage.m_slash,
				["pierce"] = hit.m_damage.m_pierce,
				["fire"] = hit.m_damage.m_fire,
				["frost"] = hit.m_damage.m_frost,
				["lightning"] = hit.m_damage.m_lightning,
				["poison"] = hit.m_damage.m_poison,
				["spirit"] = hit.m_damage.m_spirit
			};
			return EventEntry.Create(eventType, parameters);
		}

		public static EventEntry FormatDeathEvent(string deathType = "unknown")
		{
			Dictionary<string, object> parameters = new Dictionary<string, object> { ["death_type"] = deathType };
			return EventEntry.Create("player_death", parameters);
		}

		public static EventEntry FormatBiomeEvent(string biome)
		{
			Dictionary<string, object> parameters = new Dictionary<string, object> { ["biome"] = biome };
			return EventEntry.Create("biome_change", parameters);
		}

		public static EventEntry FormatSkillEvent(string skillName, float oldLevel, float newLevel)
		{
			Dictionary<string, object> parameters = new Dictionary<string, object>
			{
				["skill_name"] = skillName,
				["old_level"] = oldLevel,
				["new_level"] = newLevel
			};
			return EventEntry.Create("skill_levelup", parameters);
		}

		public static EventEntry FormatPortalEvent(string portalName, bool enter)
		{
			Dictionary<string, object> parameters = new Dictionary<string, object>
			{
				["portal_name"] = portalName,
				["enter"] = enter
			};
			return EventEntry.Create("portal_use", parameters);
		}

		public static EventEntry FormatBuildEvent(string buildName, int count)
		{
			Dictionary<string, object> parameters = new Dictionary<string, object>
			{
				["build_name"] = buildName,
				["count"] = count
			};
			return EventEntry.Create("building_built", parameters);
		}

		public static EventEntry FormatMapPinEvent(string pinName, float x, float y, float z)
		{
			Dictionary<string, object> parameters = new Dictionary<string, object>
			{
				["pin_name"] = pinName,
				["pin_x"] = x,
				["pin_y"] = y,
				["pin_z"] = z
			};
			return EventEntry.Create("map_pin_added", parameters);
		}
	}
	public class SessionManager
	{
		private readonly string _sessionFilePath;

		public string SessionId { get; private set; }

		public long SessionStart { get; private set; }

		public long SessionEnd { get; private set; }

		public bool IsActive { get; private set; }

		public SessionManager(string valheimDataPath)
		{
			_sessionFilePath = Path.Combine(valheimDataPath, "GCValheimStats", "session.dat");
			Directory.CreateDirectory(Path.GetDirectoryName(_sessionFilePath));
		}

		public void StartSession()
		{
			if (!TryRecoverSession() || !IsActive)
			{
				SessionId = Guid.NewGuid().ToString();
				SessionStart = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
				SessionEnd = 0L;
				IsActive = true;
				SaveSession();
			}
		}

		public void EndSession()
		{
			if (IsActive)
			{
				SessionEnd = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
				IsActive = false;
				SaveSession();
			}
		}

		public void ClearSession()
		{
			SessionId = null;
			SessionStart = 0L;
			SessionEnd = 0L;
			IsActive = false;
			try
			{
				if (File.Exists(_sessionFilePath))
				{
					File.Delete(_sessionFilePath);
				}
			}
			catch (Exception ex)
			{
				Log.W("Failed to clear session: " + ex.Message);
			}
		}

		private bool TryRecoverSession()
		{
			try
			{
				if (!File.Exists(_sessionFilePath))
				{
					return false;
				}
				string[] array = File.ReadAllLines(_sessionFilePath);
				if (array.Length < 3)
				{
					return false;
				}
				SessionId = array[0];
				if (!long.TryParse(array[1], out var result))
				{
					return false;
				}
				if (!long.TryParse(array[2], out var result2))
				{
					return false;
				}
				SessionStart = result;
				SessionEnd = result2;
				IsActive = result2 == 0;
				return true;
			}
			catch
			{
				return false;
			}
		}

		private void SaveSession()
		{
			try
			{
				File.WriteAllText(_sessionFilePath, $"{SessionId}\n{SessionStart}\n{SessionEnd}");
			}
			catch (Exception ex)
			{
				Log.W("Failed to save session: " + ex.Message);
			}
		}
	}
	public static class WorldStatsCollector
	{
		private static object GetWorldObject()
		{
			try
			{
				Type type = typeof(ZNet).Assembly.GetType("WorldGenerator");
				if (type == null)
				{
					return null;
				}
				FieldInfo field = type.GetField("m_instance", BindingFlags.Static | BindingFlags.NonPublic);
				if (field == null)
				{
					return null;
				}
				object value = field.GetValue(null);
				if (value == null)
				{
					return null;
				}
				FieldInfo field2 = type.GetField("m_world", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field2 == null)
				{
					return null;
				}
				return field2.GetValue(value);
			}
			catch
			{
			}
			return null;
		}

		private static string GetWorldSeed()
		{
			try
			{
				object worldObject = GetWorldObject();
				if (worldObject == null)
				{
					return "Unknown";
				}
				object obj = worldObject.GetType().GetField("m_seed")?.GetValue(worldObject);
				if (obj != null)
				{
					return obj.ToString();
				}
			}
			catch
			{
			}
			return "Unknown";
		}

		private static string GetWorldSeedName()
		{
			try
			{
				object worldObject = GetWorldObject();
				if (worldObject == null)
				{
					return "Unknown";
				}
				object obj = worldObject.GetType().GetField("m_seedName")?.GetValue(worldObject);
				if (obj != null)
				{
					return obj.ToString();
				}
			}
			catch
			{
			}
			return "Unknown";
		}

		private static long GetWorldUid()
		{
			try
			{
				object worldObject = GetWorldObject();
				if (worldObject == null)
				{
					return 0L;
				}
				object obj = worldObject.GetType().GetField("m_uid")?.GetValue(worldObject);
				if (obj != null)
				{
					return (long)obj;
				}
			}
			catch
			{
			}
			return 0L;
		}

		public static string GetWorldPreset()
		{
			try
			{
				foreach (string activeGlobalKey in GetActiveGlobalKeys())
				{
					if (activeGlobalKey.StartsWith("preset "))
					{
						string[] array = activeGlobalKey.Substring(7).Split(new char[1] { ':' });
						if (array.Length != 0)
						{
							return array[0];
						}
					}
				}
			}
			catch
			{
			}
			return "Default";
		}

		public static string GetGameMode()
		{
			try
			{
				foreach (string activeGlobalKey in GetActiveGlobalKeys())
				{
					if (!activeGlobalKey.StartsWith("preset "))
					{
						continue;
					}
					string[] array = activeGlobalKey.Substring(7).Split(new char[1] { ':' });
					foreach (string text in array)
					{
						if (text.StartsWith("combat_"))
						{
							return text.Substring(7);
						}
					}
				}
			}
			catch
			{
			}
			return "Default";
		}

		public static List<string> GetWorldModifiers()
		{
			List<string> list = new List<string>();
			try
			{
				foreach (string activeGlobalKey in GetActiveGlobalKeys())
				{
					if (activeGlobalKey.StartsWith("preset "))
					{
						string[] collection = activeGlobalKey.Substring(7).Split(new char[1] { ':' });
						list.AddRange(collection);
					}
					else if (!activeGlobalKey.Contains(" ") && activeGlobalKey.Length > 0)
					{
						list.Add(activeGlobalKey);
					}
				}
			}
			catch
			{
			}
			return list;
		}

		private static List<string> GetActiveGlobalKeys()
		{
			List<string> list = new List<string>();
			try
			{
				Type type = typeof(ZNet).Assembly.GetType("ZoneSystem");
				if (type == null)
				{
					return list;
				}
				object obj = type.GetProperty("instance", BindingFlags.Static | BindingFlags.Public)?.GetValue(null);
				if (obj == null)
				{
					return list;
				}
				FieldInfo field = obj.GetType().GetField("m_globalKeys", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field == null)
				{
					return list;
				}
				if (field.GetValue(obj) is HashSet<string> collection)
				{
					list.AddRange(collection);
				}
			}
			catch
			{
			}
			return list;
		}

		public static bool IsServer()
		{
			try
			{
				if ((Object)(object)ZNet.instance != (Object)null)
				{
					return ZNet.instance.IsServer();
				}
			}
			catch
			{
			}
			return false;
		}

		public static bool IsDedicated()
		{
			try
			{
				if ((Object)(object)ZNet.instance != (Object)null)
				{
					return ZNet.instance.IsDedicated();
				}
			}
			catch
			{
			}
			return false;
		}

		public static int GetPlayerCount()
		{
			try
			{
				if ((Object)(object)ZNet.instance != (Object)null)
				{
					return ZNet.instance.GetPlayerList()?.Count ?? 0;
				}
			}
			catch
			{
			}
			return 0;
		}

		public static Dictionary<string, object> CollectWorldInfo()
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object> { ["timestamp"] = DateTimeOffset.UtcNow.ToUnixTimeSeconds() };
			try
			{
				if ((Object)(object)ZNet.instance == (Object)null)
				{
					return dictionary;
				}
				dictionary["world_name"] = ZNet.instance.GetWorldName();
				dictionary["world_seed"] = GetWorldSeed();
				dictionary["world_seed_name"] = GetWorldSeedName();
				dictionary["world_uid"] = GetWorldUid();
				dictionary["is_server"] = ZNet.instance.IsServer();
				dictionary["is_dedicated"] = ZNet.instance.IsDedicated();
				dictionary["player_count"] = ZNet.instance.GetPlayerList()?.Count ?? 0;
				Assembly assembly = typeof(ZNet).Assembly;
				Type type = assembly.GetType("WorldGenerator");
				if (type != null)
				{
					string[] array = new string[15]
					{
						"worldSize", "waterEdge", "maxMarshDistance", "minDarklandNoise", "maxDarklandDistance", "oceanBiomeScale", "oceanBiomeMinNoise", "oceanBiomeMaxNoise", "oceanBiomeMinDistance", "oceanBiomeMinDistanceBuffer",
						"mountainBaseHeightMin", "deepNorthMinDistance", "deepNorthYOffset", "ashlandsMinDistance", "ashlandsYOffset"
					};
					foreach (string text in array)
					{
						FieldInfo field = type.GetField(text, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
						if (field != null)
						{
							try
							{
								dictionary[text] = field.GetValue(null);
							}
							catch
							{
							}
						}
					}
				}
				object worldObject = GetWorldObject();
				if (worldObject != null)
				{
					FieldInfo field2 = worldObject.GetType().GetField("m_startingGlobalKeys", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field2 != null && field2.GetValue(worldObject) is IList list)
					{
						List<string> list2 = new List<string>();
						foreach (object item in list)
						{
							list2.Add(item.ToString());
						}
						dictionary["starting_global_keys"] = list2;
					}
					FieldInfo field3 = worldObject.GetType().GetField("m_worldVersion", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field3 != null)
					{
						dictionary["world_version"] = field3.GetValue(worldObject);
					}
					FieldInfo field4 = worldObject.GetType().GetField("m_worldGenVersion", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field4 != null)
					{
						dictionary["world_gen_version"] = field4.GetValue(worldObject);
					}
					FieldInfo field5 = worldObject.GetType().GetField("m_startingKeysChanged", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field5 != null)
					{
						dictionary["starting_keys_changed"] = field5.GetValue(worldObject);
					}
				}
				try
				{
					Type type2 = assembly.GetType("ZoneSystem");
					if (type2 != null)
					{
						object obj2 = type2.GetProperty("instance", BindingFlags.Static | BindingFlags.Public)?.GetValue(null);
						if (obj2 != null)
						{
							FieldInfo field6 = obj2.GetType().GetField("m_globalKeys", BindingFlags.Instance | BindingFlags.NonPublic);
							if (field6 != null)
							{
								object value = field6.GetValue(obj2);
								if (value != null)
								{
									List<string> list3 = new List<string>();
									foreach (object item2 in (IEnumerable)value)
									{
										list3.Add(item2.ToString());
									}
									dictionary["active_global_keys"] = list3;
								}
							}
						}
					}
				}
				catch (Exception ex)
				{
					Log.W("Failed to get global keys: " + ex.Message);
				}
				try
				{
					Player localPlayer = Player.m_localPlayer;
					if ((Object)(object)localPlayer != (Object)null)
					{
						dictionary["character_name"] = localPlayer.GetPlayerName();
						dictionary["character_uid"] = localPlayer.GetPlayerID();
					}
				}
				catch
				{
				}
				dictionary["active_buffs"] = GetActiveBuffs();
				dictionary["installed_mods"] = GetInstalledMods();
			}
			catch (Exception arg)
			{
				Log.E($"CollectWorldInfo error: {arg}");
			}
			return dictionary;
		}

		private static List<string> GetActiveBuffs()
		{
			List<string> list = new List<string>();
			try
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					return list;
				}
				object obj = typeof(Player).GetField("m_seSystem", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(localPlayer);
				if (obj == null)
				{
					return list;
				}
				if (!(obj.GetType().GetField("m_statusEffectList", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(obj) is IList list2))
				{
					return list;
				}
				foreach (object item in list2)
				{
					if (item != null)
					{
						string text = item.GetType().GetField("m_name")?.GetValue(item)?.ToString();
						if (!string.IsNullOrEmpty(text))
						{
							list.Add(text);
						}
					}
				}
			}
			catch
			{
			}
			return list;
		}

		private static List<Dictionary<string, string>> GetInstalledMods()
		{
			List<Dictionary<string, string>> list = new List<Dictionary<string, string>>();
			try
			{
				Type type = typeof(BaseUnityPlugin).Assembly.GetType("BepInEx.Bootstrap.Chainloader");
				if (type == null)
				{
					return list;
				}
				PropertyInfo property = type.GetProperty("PluginInfos", BindingFlags.Static | BindingFlags.Public);
				if (property == null)
				{
					return list;
				}
				if (!(property.GetValue(null) is IDictionary dictionary))
				{
					return list;
				}
				foreach (DictionaryEntry item in dictionary)
				{
					object value = item.Value;
					if (value == null)
					{
						continue;
					}
					object obj = value.GetType().GetProperty("Metadata")?.GetValue(value);
					if (obj != null)
					{
						Dictionary<string, string> dictionary2 = new Dictionary<string, string>();
						string value2 = obj.GetType().GetProperty("GUID")?.GetValue(obj)?.ToString();
						string value3 = obj.GetType().GetProperty("Name")?.GetValue(obj)?.ToString();
						string value4 = obj.GetType().GetProperty("Version")?.GetValue(obj)?.ToString();
						if (!string.IsNullOrEmpty(value2))
						{
							dictionary2["guid"] = value2;
						}
						if (!string.IsNullOrEmpty(value3))
						{
							dictionary2["name"] = value3;
						}
						if (!string.IsNullOrEmpty(value4))
						{
							dictionary2["version"] = value4;
						}
						if (dictionary2.Count > 0)
						{
							list.Add(dictionary2);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.W("Failed to get installed mods: " + ex.Message);
			}
			return list;
		}
	}
}
namespace GCValheimStats.Batch
{
	public class BatchBuilder
	{
		private readonly EventQueue _queue;

		private readonly Func<string> _getSteamId;

		private readonly Func<string> _getWorldSeed;

		private readonly Func<string> _getWorldName;

		private readonly Func<string> _getWorldPreset;

		private readonly Func<string> _getGameMode;

		private readonly Func<List<string>> _getWorldModifiers;

		private readonly Func<bool> _getIsServer;

		private readonly Func<bool> _getIsDedicated;

		private readonly Func<int> _getPlayerCount;

		private readonly Func<string> _getCharacterName;

		private readonly Func<long> _getCharacterUid;

		private readonly Func<string> _getSessionId;

		private readonly Func<long> _getSessionStart;

		public BatchBuilder(EventQueue queue, Func<string> getSteamId, Func<string> getWorldSeed, Func<string> getWorldName, Func<string> getWorldPreset, Func<string> getGameMode, Func<List<string>> getWorldModifiers, Func<bool> getIsServer, Func<bool> getIsDedicated, Func<int> getPlayerCount, Func<string> getCharacterName, Func<long> getCharacterUid, Func<string> getSessionId, Func<long> getSessionStart)
		{
			_queue = queue;
			_getSteamId = getSteamId;
			_getWorldSeed = getWorldSeed;
			_getWorldName = getWorldName;
			_getWorldPreset = getWorldPreset;
			_getGameMode = getGameMode;
			_getWorldModifiers = getWorldModifiers;
			_getIsServer = getIsServer;
			_getIsDedicated = getIsDedicated;
			_getPlayerCount = getPlayerCount;
			_getCharacterName = getCharacterName;
			_getCharacterUid = getCharacterUid;
			_getSessionId = getSessionId;
			_getSessionStart = getSessionStart;
		}

		public BatchData BuildBatch()
		{
			List<EventEntry> list = _queue.DequeueAll();
			if (list.Count == 0)
			{
				return null;
			}
			BatchData batchData = BatchData.Create(_getSteamId(), _getWorldSeed(), _getWorldName(), _getWorldPreset(), _getGameMode(), _getWorldModifiers(), _getIsServer(), _getIsDedicated(), _getPlayerCount(), _getCharacterName(), _getCharacterUid(), _getSessionId());
			batchData.SessionStart = _getSessionStart();
			batchData.SessionEnd = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			batchData.Events = list;
			batchData.TotalEvents = list.Count;
			return batchData;
		}
	}
	public class BatchData
	{
		public string BatchId { get; set; }

		public string SteamId { get; set; }

		public string WorldSeed { get; set; }

		public string WorldName { get; set; }

		public string WorldPreset { get; set; }

		public string GameMode { get; set; }

		public List<string> WorldModifiers { get; set; }

		public bool IsServer { get; set; }

		public bool IsDedicated { get; set; }

		public int PlayerCount { get; set; }

		public string CharacterName { get; set; }

		public long CharacterUid { get; set; }

		public string SessionId { get; set; }

		public long SessionStart { get; set; }

		public long SessionEnd { get; set; }

		public List<EventEntry> Events { get; set; }

		public int TotalEvents { get; set; }

		public bool OfflineCollected { get; set; }

		public string CollectedAt { get; set; }

		public string ToJson()
		{
			List<string> list = new List<string>();
			if (Events != null)
			{
				foreach (EventEntry @event in Events)
				{
					list.Add(@event.ToJson());
				}
			}
			List<string> list2 = new List<string>();
			if (WorldModifiers != null)
			{
				foreach (string worldModifier in WorldModifiers)
				{
					list2.Add("\"" + EventEntry.EscapeJson(worldModifier) + "\"");
				}
			}
			return "{\"batch_id\":\"" + BatchId + "\",\"steam_id\":\"" + SteamId + "\",\"world_seed\":\"" + WorldSeed + "\",\"world_name\":\"" + EventEntry.EscapeJson(WorldName) + "\",\"world_preset\":\"" + EventEntry.EscapeJson(WorldPreset ?? "Unknown") + "\",\"game_mode\":\"" + EventEntry.EscapeJson(GameMode ?? "Unknown") + "\",\"world_modifiers\":[" + string.Join(",", list2) + "],\"is_server\":" + (IsServer ? "true" : "false") + ",\"is_dedicated\":" + (IsDedicated ? "true" : "false") + "," + $"\"player_count\":{PlayerCount}," + "\"character_name\":\"" + EventEntry.EscapeJson(CharacterName) + "\"," + $"\"character_uid\":{CharacterUid}," + "\"session_id\":\"" + SessionId + "\"," + $"\"session_start\":{SessionStart}," + $"\"session_end\":{SessionEnd}," + "\"events\":[" + string.Join(",", list) + "]," + $"\"total_events\":{TotalEvents}," + "\"offline_collected\":" + (OfflineCollected ? "true" : "false") + ",\"collected_at\":\"" + CollectedAt + "\"}";
		}

		public static BatchData FromJson(string json)
		{
			BatchData batchData = new BatchData
			{
				Events = new List<EventEntry>(),
				WorldModifiers = new List<string>()
			};
			batchData.BatchId = EventEntry.ExtractString(json, "batch_id") ?? Guid.NewGuid().ToString();
			batchData.SteamId = EventEntry.ExtractString(json, "steam_id") ?? "0";
			batchData.WorldSeed = EventEntry.ExtractString(json, "world_seed") ?? "0";
			batchData.WorldName = EventEntry.ExtractString(json, "world_name") ?? "Unknown";
			batchData.WorldPreset = EventEntry.ExtractString(json, "world_preset") ?? "Unknown";
			batchData.GameMode = EventEntry.ExtractString(json, "game_mode") ?? "Unknown";
			batchData.IsServer = EventEntry.ExtractString(json, "is_server") == "true";
			batchData.IsDedicated = EventEntry.ExtractString(json, "is_dedicated") == "true";
			batchData.PlayerCount = (int)EventEntry.ExtractLong(json, "player_count");
			batchData.CharacterName = EventEntry.ExtractString(json, "character_name") ?? "Unknown";
			batchData.CharacterUid = EventEntry.ExtractLong(json, "character_uid");
			batchData.SessionId = EventEntry.ExtractString(json, "session_id") ?? "";
			batchData.SessionStart = EventEntry.ExtractLong(json, "session_start");
			batchData.SessionEnd = EventEntry.ExtractLong(json, "session_end");
			batchData.TotalEvents = (int)EventEntry.ExtractLong(json, "total_events");
			batchData.CollectedAt = EventEntry.ExtractString(json, "collected_at") ?? DateTime.UtcNow.ToString("o");
			string text = EventEntry.ExtractString(json, "offline_collected");
			batchData.OfflineCollected = text == "true";
			int num = json.IndexOf("\"world_modifiers\":[");
			if (num >= 0)
			{
				int num2 = json.IndexOf('[', num);
				int num3 = FindMatchingBracket(json, num2);
				if (num3 > num2)
				{
					string text2 = json.Substring(num2 + 1, num3 - num2 - 1).Trim();
					if (text2.Length > 0)
					{
						string[] array = text2.Split(new char[1] { ',' });
						for (int i = 0; i < array.Length; i++)
						{
							string text3 = array[i].Trim().Trim(new char[1] { '"' });
							if (text3.Length > 0)
							{
								batchData.WorldModifiers.Add(text3);
							}
						}
					}
				}
			}
			int num4 = json.IndexOf("\"events\":[");
			if (num4 >= 0)
			{
				int num5 = json.IndexOf('[', num4);
				int num6 = FindMatchingBracket(json, num5);
				if (num6 > num5)
				{
					string text4 = json.Substring(num5 + 1, num6 - num5 - 1).Trim();
					if (text4.Length > 0)
					{
						int num7 = 0;
						int num8 = 0;
						for (int j = 0; j <= text4.Length; j++)
						{
							switch ((j < text4.Length) ? text4[j] : ',')
							{
							case '{':
								num7++;
								break;
							case '}':
								num7--;
								break;
							case ',':
								if (num7 == 0)
								{
									string text5 = text4.Substring(num8, j - num8).Trim();
									if (text5.StartsWith("{"))
									{
										batchData.Events.Add(EventEntry.FromJson(text5));
									}
									num8 = j + 1;
								}
								break;
							}
						}
					}
				}
			}
			batchData.TotalEvents = batchData.Events.Count;
			return batchData;
		}

		private static int FindMatchingBracket(string json, int openIndex)
		{
			if (openIndex < 0 || openIndex >= json.Length)
			{
				return -1;
			}
			int num = 0;
			for (int i = openIndex; i < json.Length; i++)
			{
				if (json[i] == '[' || json[i] == '{')
				{
					num++;
				}
				else if (json[i] == ']' || json[i] == '}')
				{
					num--;
				}
				if (num == 0)
				{
					return i;
				}
			}
			return -1;
		}

		public static BatchData Create(string steamId, string worldSeed, string worldName, string worldPreset, string gameMode, List<string> worldModifiers, bool isServer, bool isDedicated, int playerCount, string characterName, long characterUid, string sessionId)
		{
			return new BatchData
			{
				BatchId = Guid.NewGuid().ToString(),
				SteamId = steamId,
				WorldSeed = worldSeed,
				WorldName = worldName,
				WorldPreset = (worldPreset ?? "Unknown"),
				GameMode = (gameMode ?? "Unknown"),
				WorldModifiers = (worldModifiers ?? new List<string>()),
				IsServer = isServer,
				IsDedicated = isDedicated,
				PlayerCount = playerCount,
				CharacterName = characterName,
				CharacterUid = characterUid,
				SessionId = sessionId,
				Events = new List<EventEntry>(),
				CollectedAt = DateTime.UtcNow.ToString("o")
			};
		}
	}
	public struct EventEntry
	{
		public long Timestamp { get; set; }

		public string EventType { get; set; }

		public Dictionary<string, object> Parameters { get; set; }

		public float[] Position { get; set; }

		public static EventEntry Create(string eventType, Dictionary<string, object> parameters = null)
		{
			//IL_0015: 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_001a: 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_0063: 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)
			Player localPlayer = Player.m_localPlayer;
			Vector3 val = ((localPlayer != null) ? ((Component)localPlayer).transform.position : Vector3.zero);
			return new EventEntry
			{
				Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
				EventType = eventType,
				Parameters = (parameters ?? new Dictionary<string, object>()),
				Position = new float[3] { val.x, val.y, val.z }
			};
		}

		public static EventEntry Create(string eventType, Vector3 position, Dictionary<string, object> parameters = null)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			return new EventEntry
			{
				Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
				EventType = eventType,
				Parameters = (parameters ?? new Dictionary<string, object>()),
				Position = new float[3] { position.x, position.y, position.z }
			};
		}

		public string ToJson()
		{
			string text = "{";
			if (Parameters != null && Parameters.Count > 0)
			{
				bool flag = true;
				foreach (KeyValuePair<string, object> parameter in Parameters)
				{
					if (!flag)
					{
						text += ",";
					}
					text = text + "\"" + EscapeJson(parameter.Key) + "\":" + ToJsonValue(parameter.Value);
					flag = false;
				}
			}
			text += "}";
			string text2 = ((Position != null) ? $"[{Position[0]},{Position[1]},{Position[2]}]" : "[0,0,0]");
			return $"{{\"t\":{Timestamp},\"e\":\"{EscapeJson(EventType)}\",\"p\":{text},\"pos\":{text2}}}";
		}

		public static EventEntry FromJson(string json)
		{
			EventEntry result = new EventEntry
			{
				Parameters = new Dictionary<string, object>(),
				Position = new float[3]
			};
			result.Timestamp = ExtractLong(json, "t");
			result.EventType = ExtractString(json, "e") ?? "unknown";
			string text = ExtractArray(json, "pos");
			if (text != null)
			{
				string[] array = text.Split(new char[1] { ',' });
				if (array.Length >= 3)
				{
					float.TryParse(array[0].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out result.Position[0]);
					float.TryParse(array[1].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out result.Position[1]);
					float.TryParse(array[2].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out result.Position[2]);
				}
			}
			string text2 = ExtractObject(json, "p");
			if (text2 != null && text2.Length > 0)
			{
				result.Parameters = ParseJsonObject(text2);
			}
			return result;
		}

		private static string ExtractObject(string json, string key)
		{
			string value = "\"" + key + "\":";
			int num = json.IndexOf(value);
			if (num < 0)
			{
				return null;
			}
			num = json.IndexOf('{', num);
			if (num < 0)
			{
				return null;
			}
			int num2 = FindMatchingBracket(json, num);
			if (num2 <= num)
			{
				return null;
			}
			return json.Substring(num + 1, num2 - num - 1);
		}

		private static Dictionary<string, object> ParseJsonObject(string json)
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			if (string.IsNullOrEmpty(json))
			{
				return dictionary;
			}
			int i = 0;
			while (i < json.Length)
			{
				for (; i < json.Length && char.IsWhiteSpace(json[i]); i++)
				{
				}
				if (i >= json.Length || json[i] != '"')
				{
					break;
				}
				i++;
				int num = i;
				for (; i < json.Length && json[i] != '"'; i++)
				{
					if (json[i] == '\\')
					{
						i++;
					}
				}
				string key = json.Substring(num, i - num);
				for (i++; i < json.Length && (char.IsWhiteSpace(json[i]) || json[i] == ':'); i++)
				{
				}
				object value = ParseJsonValue(json, ref i);
				dictionary[key] = value;
				for (; i < json.Length && (char.IsWhiteSpace(json[i]) || json[i] == ','); i++)
				{
				}
			}
			return dictionary;
		}

		private static object ParseJsonValue(string json, ref int i)
		{
			while (i < json.Length && char.IsWhiteSpace(json[i]))
			{
				i++;
			}
			if (i >= json.Length)
			{
				return null;
			}
			switch (json[i])
			{
			case '"':
			{
				i++;
				int num4 = i;
				while (i < json.Length && json[i] != '"')
				{
					if (json[i] == '\\')
					{
						i++;
					}
					i++;
				}
				string result3 = json.Substring(num4, i - num4);
				i++;
				return result3;
			}
			case '{':
			{
				int num2 = i;
				int num3 = FindMatchingBracket(json, i);
				if (num3 > num2)
				{
					i = num3 + 1;
					return ParseJsonObject(json.Substring(num2 + 1, num3 - num2 - 1));
				}
				i++;
				return null;
			}
			case '[':
			{
				int num5 = i;
				int num6 = FindMatchingBracket(json, i);
				if (num6 > num5)
				{
					i = num6 + 1;
					return ParseJsonArray(json.Substring(num5 + 1, num6 - num5 - 1));
				}
				i++;
				return null;
			}
			default:
			{
				int num = i;
				while (i < json.Length && json[i] != ',' && json[i] != '}' && json[i] != ']' && !char.IsWhiteSpace(json[i]))
				{
					i++;
				}
				string text = json.Substring(num, i - num);
				switch (text)
				{
				case "true":
					return true;
				case "false":
					return false;
				case "null":
					return null;
				default:
				{
					if (long.TryParse(text, out var result))
					{
						return result;
					}
					if (double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
					{
						return result2;
					}
					return text;
				}
				}
			}
			}
		}

		private static List<object> ParseJsonArray(string json)
		{
			List<object> list = new List<object>();
			if (string.IsNullOrEmpty(json))
			{
				return list;
			}
			int i = 0;
			while (i < json.Length)
			{
				for (; i < json.Length && char.IsWhiteSpace(json[i]); i++)
				{
				}
				if (i >= json.Length)
				{
					break;
				}
				object item = ParseJsonValue(json, ref i);
				list.Add(item);
				for (; i < json.Length && (char.IsWhiteSpace(json[i]) || json[i] == ','); i++)
				{
				}
			}
			return list;
		}

		internal static string EscapeJson(string s)
		{
			if (s == null)
			{
				return "";
			}
			return s.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\n", "\\n")
				.Replace("\r", "\\r")
				.Replace("\t", "\\t");
		}

		internal static string ToJsonValue(object v)
		{
			if (v == null)
			{
				return "null";
			}
			if (v is string s)
			{
				return "\"" + EscapeJson(s) + "\"";
			}
			if (v is bool)
			{
				if (!(bool)v)
				{
					return "false";
				}
				return "true";
			}
			if (v is int num)
			{
				return num.ToString();
			}
			if (v is long num2)
			{
				return num2.ToString();
			}
			if (v is float num3)
			{
				return num3.ToString(CultureInfo.InvariantCulture);
			}
			if (v is double num4)
			{
				return num4.ToString(CultureInfo.InvariantCulture);
			}
			if (v is IList list)
			{
				List<string> list2 = new List<string>();
				foreach (object item in list)
				{
					list2.Add(ToJsonValue(item));
				}
				return "[" + string.Join(",", list2) + "]";
			}
			if (v is IDictionary dictionary)
			{
				List<string> list3 = new List<string>();
				foreach (DictionaryEntry item2 in dictionary)
				{
					list3.Add("\"" + EscapeJson(item2.Key.ToString()) + "\":" + ToJsonValue(item2.Value));
				}
				return "{" + string.Join(",", list3) + "}";
			}
			return "\"" + EscapeJson(v.ToString()) + "\"";
		}

		internal static string ExtractString(string json, string key)
		{
			string text = "\"" + key + "\":\"";
			int num = json.IndexOf(text);
			if (num < 0)
			{
				return null;
			}
			num += text.Length;
			int num2 = json.IndexOf('"', num);
			if (num2 < 0)
			{
				return null;
			}
			return json.Substring(num, num2 - num);
		}

		internal static long ExtractLong(string json, string key)
		{
			string text = "\"" + key + "\":";
			int num = json.IndexOf(text);
			if (num < 0)
			{
				return 0L;
			}
			num += text.Length;
			int i;
			for (i = num; i < json.Length && (char.IsDigit(json[i]) || json[i] == '-'); i++)
			{
			}
			long.TryParse(json.Substring(num, i - num), out var result);
			return result;
		}

		internal static string ExtractArray(string json, string key)
		{
			string value = "\"" + key + "\":";
			int num = json.IndexOf(value);
			if (num < 0)
			{
				return null;
			}
			num = json.IndexOf('[', num);
			if (num < 0)
			{
				return null;
			}
			int num2 = json.IndexOf(']', num);
			if (num2 < 0)
			{
				return null;
			}
			return json.Substring(num + 1, num2 - num - 1);
		}

		private static int FindMatchingBracket(string json, int openIndex)
		{
			if (openIndex < 0 || openIndex >= json.Length)
			{
				return -1;
			}
			int num = 0;
			for (int i = openIndex; i < json.Length; i++)
			{
				if (json[i] == '[' || json[i] == '{')
				{
					num++;
				}
				else if (json[i] == ']' || json[i] == '}')
				{
					num--;
				}
				if (num == 0)
				{
					return i;
				}
			}
			return -1;
		}
	}
	public class EventQueue
	{
		private readonly ConcurrentQueue<EventEntry> _queue = new ConcurrentQueue<EventEntry>();

		public int Count => _queue.Count;

		public bool IsEmpty => _queue.IsEmpty;

		public void Enqueue(EventEntry entry)
		{
			_queue.Enqueue(entry);
		}

		public List<EventEntry> DequeueAll()
		{
			List<EventEntry> list = new List<EventEntry>();
			EventEntry result;
			while (_queue.TryDequeue(out result))
			{
				list.Add(result);
			}
			return list;
		}

		public EventEntry? TryDequeue()
		{
			if (!_queue.TryDequeue(out var result))
			{
				return null;
			}
			return result;
		}

		public void Clear()
		{
			EventEntry result;
			while (_queue.TryDequeue(out result))
			{
			}
		}
	}
	public class QueueStorage
	{
		private readonly string _queuePath;

		public QueueStorage(string valheimDataPath)
		{
			_queuePath = Path.Combine(valheimDataPath, "GCValheimStats", "queue");
			Directory.CreateDirectory(_queuePath);
		}

		public void SaveBatch(BatchData batch, byte[] aesKey, byte[] hmacKey)
		{
			string s = batch.ToJson();
			byte[] array = CryptoHelper.Encrypt(Encoding.UTF8.GetBytes(s), aesKey);
			string s2 = CryptoHelper.ComputeHmac(array, hmacKey);
			byte[] bytes = Encoding.UTF8.GetBytes(s2);
			string path = Path.Combine(_queuePath, batch.BatchId + ".enc");
			byte[] bytes2 = Encoding.UTF8.GetBytes("|");
			using FileStream fileStream = File.Create(path);
			fileStream.Write(array, 0, array.Length);
			fileStream.Write(bytes2, 0, bytes2.Length);
			fileStream.Write(bytes, 0, bytes.Length);
		}

		public BatchData LoadBatch(string path, byte[] aesKey, byte[] hmacKey)
		{
			byte[] array = File.ReadAllBytes(path);
			int num = Array.LastIndexOf(array, (byte)124);
			if (num < 0)
			{
				throw new InvalidDataException("Invalid batch file format: " + path);
			}
			byte[] array2 = new byte[num];
			Array.Copy(array, 0, array2, 0, num);
			string receivedHmac = Encoding.UTF8.GetString(array, num + 1, array.Length - num - 1);
			if (!CryptoHelper.VerifyHmac(array2, hmacKey, receivedHmac))
			{
				throw new SecurityException("HMAC verification failed for " + path);
			}
			byte[] bytes = CryptoHelper.Decrypt(array2, aesKey);
			return BatchData.FromJson(Encoding.UTF8.GetString(bytes));
		}

		public List<BatchData> LoadAllPending(byte[] aesKey, byte[] hmacKey)
		{
			List<BatchData> list = new List<BatchData>();
			if (!Directory.Exists(_queuePath))
			{
				return list;
			}
			string[] files = Directory.GetFiles(_queuePath, "*.enc");
			foreach (string text in files)
			{
				try
				{
					list.Add(LoadBatch(text, aesKey, hmacKey));
				}
				catch (Exception ex)
				{
					Log.E("Failed to load batch " + text + ": " + ex.Message);
				}
			}
			return list;
		}

		public void DeleteBatch(string batchId)
		{
			string path = Path.Combine(_queuePath, batchId + ".enc");
			if (File.Exists(path))
			{
				File.Delete(path);
			}
		}

		public int GetPendingCount()
		{
			if (!Directory.Exists(_queuePath))
			{
				return 0;
			}
			return Directory.GetFiles(_queuePath, "*.enc").Length;
		}

		public void DeleteAllPending()
		{
			if (!Directory.Exists(_queuePath))
			{
				return;
			}
			string[] files = Directory.GetFiles(_queuePath, "*.enc");
			foreach (string path in files)
			{
				try
				{
					File.Delete(path);
				}
				catch
				{
				}
			}
		}
	}
}
namespace GCValheimStats.Security
{
	public static class CryptoHelper
	{
		public static byte[] Encrypt(byte[] data, byte[] key)
		{
			if (data == null || data.Length == 0)
			{
				throw new ArgumentException("Data cannot be null or empty", "data");
			}
			if (key == null || key.Length != 32)
			{
				throw new ArgumentException("Key must be 32 bytes", "key");
			}
			byte[] array = new byte[16];
			byte[] array2 = new byte[16];
			using (RNGCryptoServiceProvider rNGCryptoServiceProvider = new RNGCryptoServiceProvider())
			{
				rNGCryptoServiceProvider.GetBytes(array);
				rNGCryptoServiceProvider.GetBytes(array2);
			}
			byte[] key2 = KeyDeriver.DeriveAesKey(key, array);
			byte[] array3;
			using (Aes aes = Aes.Create())
			{
				aes.Key = key2;
				aes.IV = array2;
				aes.Mode = CipherMode.CBC;
				aes.Padding = PaddingMode.PKCS7;
				using ICryptoTransform transform = aes.CreateEncryptor();
				using MemoryStream memoryStream = new MemoryStream();
				using CryptoStream cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Write);
				cryptoStream.Write(data, 0, data.Length);
				cryptoStream.FlushFinalBlock();
				array3 = memoryStream.ToArray();
			}
			byte[] array4 = new byte[32 + array3.Length];
			Buffer.BlockCopy(array, 0, array4, 0, 16);
			Buffer.BlockCopy(array2, 0, array4, 16, 16);
			Buffer.BlockCopy(array3, 0, array4, 32, array3.Length);
			return array4;
		}

		public static byte[] Decrypt(byte[] encrypted, byte[] key)
		{
			if (encrypted == null || encrypted.Length < 33)
			{
				throw new ArgumentException("Encrypted data too short", "encrypted");
			}
			if (key == null || key.Length != 32)
			{
				throw new ArgumentException("Key must be 32 bytes", "key");
			}
			byte[] array = new byte[16];
			byte[] array2 = new byte[16];
			byte[] array3 = new byte[encrypted.Length - 32];
			Buffer.BlockCopy(encrypted, 0, array, 0, 16);
			Buffer.BlockCopy(encrypted, 16, array2, 0, 16);
			Buffer.BlockCopy(encrypted, 32, array3, 0, array3.Length);
			byte[] key2 = KeyDeriver.DeriveAesKey(key, array);
			using Aes aes = Aes.Create();
			aes.Key = key2;
			aes.IV = array2;
			aes.Mode = CipherMode.CBC;
			aes.Padding = PaddingMode.PKCS7;
			using ICryptoTransform transform = aes.CreateDecryptor();
			using MemoryStream stream = new MemoryStream(array3);
			using CryptoStream cryptoStream = new CryptoStream(stream, transform, CryptoStreamMode.Read);
			using MemoryStream memoryStream = new MemoryStream();
			cryptoStream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}

		public static string ComputeHmac(byte[] data, byte[] key)
		{
			if (data == null || data.Length == 0)
			{
				throw new ArgumentException("Data cannot be null or empty", "data");
			}
			if (key == null || key.Length != 32)
			{
				throw new ArgumentException("Key must be 32 bytes", "key");
			}
			using HMACSHA256 hMACSHA = new HMACSHA256(key);
			return BitConverter.ToString(hMACSHA.ComputeHash(data)).Replace("-", "").ToLowerInvariant();
		}

		public static bool VerifyHmac(byte[] data, byte[] key, string receivedHmac)
		{
			if (string.IsNullOrEmpty(receivedHmac))
			{
				return false;
			}
			return string.Equals(ComputeHmac(data, key), receivedHmac, StringComparison.OrdinalIgnoreCase);
		}
	}
	internal static class DataProtector
	{
		private const string WmiClass = "Win32_Processor";

		private const string WmiProperty = "ProcessorId";

		private static readonly byte[] XorKey = new byte[16]
		{
			163, 177, 199, 212, 229, 246, 23, 40, 57, 74,
			91, 108, 125, 142, 159, 10
		};

		private static readonly byte[] EncryptedSalt = new byte[16]
		{
			228, 242, 145, 181, 137, 165, 96, 73, 75, 14,
			12, 11, 17, 242, 107, 58
		};

		public static string GetHardwareId()
		{
			try
			{
				string machineName = Environment.MachineName;
				string wmiProcessorId = GetWmiProcessorId();
				return machineName + "|" + wmiProcessorId;
			}
			catch
			{
				return Environment.MachineName + "|" + Environment.OSVersion.VersionString;
			}
		}

		private static string GetWmiProcessorId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ManagementObjectSearcher val = new ManagementObjectSearcher("SELECT ProcessorId FROM Win32_Processor");
				try
				{
					ManagementObjectEnumerator enumerator = val.Get().GetEnumerator();
					try
					{
						while (enumerator.MoveNext())
						{
							string text = ((ManagementBaseObject)(ManagementObject)enumerator.Current)["ProcessorId"]?.ToString();
							if (!string.IsNullOrEmpty(text))
							{
								return text;
							}
						}
					}
					finally
					{
						((IDisposable)enumerator)?.Dispose();
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
			catch
			{
			}
			return Environment.OSVersion.VersionString;
		}

		public static byte[] GetObfuscatedSalt()
		{
			byte[] array = new byte[EncryptedSalt.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = (byte)(EncryptedSalt[i] ^ XorKey[i]);
			}
			return array;
		}
	}
	public static class KeyDeriver
	{
		private const int Iterations = 100000;

		private const int MasterKeyLength = 64;

		public static (byte[] aesKey, byte[] hmacKey) DeriveKey(long steamId)
		{
			string hardwareId = DataProtector.GetHardwareId();
			using Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(salt: DataProtector.GetObfuscatedSalt(), password: hardwareId + "|" + steamId, iterations: 100000, hashAlgorithm: HashAlgorithmName.SHA256);
			byte[] bytes = rfc2898DeriveBytes.GetBytes(64);
			byte[] array = new byte[32];
			byte[] array2 = new byte[32];
			Buffer.BlockCopy(bytes, 0, array, 0, 32);
			Buffer.BlockCopy(bytes, 32, array2, 0, 32);
			return (aesKey: array, hmacKey: array2);
		}

		public static byte[] DeriveAesKey(byte[] masterKey, byte[] salt)
		{
			using Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(masterKey, salt, 10000, HashAlgorithmName.SHA256);
			return rfc2898DeriveBytes.GetBytes(32);
		}
	}
}