#define UNITY_ASSERTIONS
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Data;
using System.Data.SqlTypes;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Tracing;
using System.Dynamic;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Net.Http;
using System.Numerics;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Linq;
using AzuExtendedPlayerInventory;
using BepInEx;
using BepInEx.Logging;
using FxResources.System.Buffers;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Microsoft.Win32.SafeHandles;
using Newtonsoft.Json;
using Newtonsoft.Json.Bson;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Linq.JsonPath;
using Newtonsoft.Json.Schema;
using Newtonsoft.Json.Serialization;
using Newtonsoft.Json.Utilities;
using TerritoryStars;
using Unity.Baselib.LowLevel;
using Unity.Burst;
using Unity.Burst.LowLevel;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Content;
using Unity.IL2CPP.CompilerServices;
using Unity.Jobs;
using Unity.Jobs.LowLevel.Unsafe;
using Unity.Profiling;
using Unity.Profiling.LowLevel;
using Unity.Profiling.LowLevel.Unsafe;
using UnityEngine;
using UnityEngine.Assertions;
using UnityEngine.Assertions.Comparers;
using UnityEngine.Bindings;
using UnityEngine.Diagnostics;
using UnityEngine.Events;
using UnityEngine.Experimental.Rendering;
using UnityEngine.Internal;
using UnityEngine.Networking.PlayerConnection;
using UnityEngine.Playables;
using UnityEngine.Profiling;
using UnityEngine.Rendering;
using UnityEngine.Rendering.RendererUtils;
using UnityEngine.SceneManagement;
using UnityEngine.Scripting;
using UnityEngine.Scripting.APIUpdating;
using UnityEngine.Serialization;
using UnityEngineInternal;
using Viper.Events;
using Viper.Utilities;

[assembly: AssemblyTitle("einherjars_client")]
[assembly: AssemblyProduct("einherjars_client")]
[assembly: AssemblyInformationalVersion("1.0.0+f0ae89656379c89a5595a5deec9df2ea22c236cc")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCompany("einherjars_client")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: <ae3b5a88-f3bf-477f-9089-8ff5232f0d34>RefSafetyRules(11)]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<44afd396-524b-4c92-aa5f-0ad3d6daca87>Embedded]
	internal sealed class <44afd396-524b-4c92-aa5f-0ad3d6daca87>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<44afd396-524b-4c92-aa5f-0ad3d6daca87>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <1361eaae-87b4-45c8-8f26-e71396fe9fa4>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <1361eaae-87b4-45c8-8f26-e71396fe9fa4>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <1361eaae-87b4-45c8-8f26-e71396fe9fa4>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<44afd396-524b-4c92-aa5f-0ad3d6daca87>Embedded]
	internal sealed class <42cac9b6-60e7-4f91-80b6-7f76cf32f091>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <42cac9b6-60e7-4f91-80b6-7f76cf32f091>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[<44afd396-524b-4c92-aa5f-0ad3d6daca87>Embedded]
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class <ae3b5a88-f3bf-477f-9089-8ff5232f0d34>RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public <ae3b5a88-f3bf-477f-9089-8ff5232f0d34>RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[HarmonyPatch(typeof(Character), "SetLevel")]
public static class CharacterSetLevelPatch
{
	public static void Postfix(Character __instance, int level)
	{
		if (!((UnityEngine.Object)(object)__instance == null))
		{
			EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = "[TerritoryStars] Character awake: " + __instance.GetHoverName() });
			EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = "[TerritoryStars] Character spawned: " + __instance.GetHoverName() });
			if (!((UnityEngine.Object)(object)__instance == null) && !__instance.IsTamed() && !__instance.IsPlayer())
			{
				UnityEngine.Debug.Log($"[TerritoryStars] {((UnityEngine.Object)(object)__instance).name} set to level {level} at {((UnityEngine.Component)(object)__instance).transform.position}");
				EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = $"[TerritoryStars] {((UnityEngine.Object)(object)__instance).name} set to level {level} at {((UnityEngine.Component)(object)__instance).transform.position}" });
			}
		}
	}
}
[HarmonyPatch(typeof(Character), "Awake")]
public static class CharacterAwakePatch
{
	[CompilerGenerated]
	private sealed class <ApplyTerritoryStars>d__1 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Character __instance;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <ApplyTerritoryStars>d__1(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = null;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>2__current = null;
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					if (TerritoryManager.Territories == null || TerritoryManager.Territories.Count == 0)
					{
						EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = "[TerritoryStars] No territories loaded." });
						return false;
					}
					UnityEngine.Vector3 position = ((UnityEngine.Component)(object)__instance).transform.position;
					MarketplaceTerritory territoryAt = TerritoryManager.GetTerritoryAt(position);
					if (territoryAt == null)
					{
						EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = $"[TerritoryStars] No zone found at position {position} for {((UnityEngine.Object)(object)__instance).name}." });
						return false;
					}
					if (territoryAt.AddStars <= 0)
					{
						EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = "[TerritoryStars] Zone '" + territoryAt.Name + "' has AddStars = 0. No boost applied." });
						return false;
					}
					if ((UnityEngine.Object)(object)__instance.m_nview == null || !__instance.m_nview.IsValid())
					{
						EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = "[TerritoryStars] Skipping SetLevel — m_nview is null or invalid for " + ((UnityEngine.Object)(object)__instance).name + "." });
						return false;
					}
					int level = __instance.GetLevel();
					if ((UnityEngine.Object)(object)__instance.m_nview != null)
					{
						if (__instance.m_nview.IsValid())
						{
							ZDO zDO = __instance.m_nview.GetZDO();
							if (zDO != null)
							{
								zDO.Set("creatureLevel", territoryAt.AddStars);
								EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = $"[TerritoryStars] ✅ Set creatureLevel ZDO to {territoryAt.AddStars} for {((UnityEngine.Object)(object)__instance).name} at {((UnityEngine.Component)(object)__instance).transform.position} in zone '{territoryAt.Name}'." });
							}
							else
							{
								EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = "[TerritoryStars] ⚠\ufe0f ZDO is null for " + ((UnityEngine.Object)(object)__instance).name + ", could not set creatureLevel." });
							}
						}
						else
						{
							EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = "[TerritoryStars] ⚠\ufe0f m_nview is not valid for " + ((UnityEngine.Object)(object)__instance).name + ", skipping creatureLevel set." });
						}
					}
					else
					{
						EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = "[TerritoryStars] ⚠\ufe0f m_nview is null for " + ((UnityEngine.Object)(object)__instance).name + ", skipping creatureLevel set." });
					}
					__instance.SetLevel(territoryAt.AddStars);
					EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = $"[TerritoryStars] Boosted {((UnityEngine.Object)(object)__instance).name} from level {level} → {territoryAt.AddStars} in territory '{territoryAt.Name}'." });
					string value = $"[TerritoryStars] Start triggered for: {__instance.GetHoverName()} at {((UnityEngine.Component)(object)__instance).transform.position}";
					EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = value });
				}
				catch (Exception arg)
				{
					EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = $"[TerritoryStars] ❌ Exception in Character.Awake patch:\n{arg}" });
				}
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public static void Postfix(Character __instance)
	{
		if (!((UnityEngine.Object)(object)__instance.m_nview == null) && __instance.m_nview.IsValid() && !((UnityEngine.Object)(object)__instance == null) && !__instance.IsTamed())
		{
			((MonoBehaviour)(object)__instance).StartCoroutine(ApplyTerritoryStars(__instance));
		}
	}

	[IteratorStateMachine(typeof(<ApplyTerritoryStars>d__1))]
	private static IEnumerator ApplyTerritoryStars(Character __instance)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ApplyTerritoryStars>d__1(0)
		{
			__instance = __instance
		};
	}
}
[HarmonyPatch(typeof(Humanoid), "EquipItem")]
[HarmonyPatch(new Type[]
{
	typeof(ItemData),
	typeof(bool)
})]
public static class EquipItemPatch
{
	[<1361eaae-87b4-45c8-8f26-e71396fe9fa4>Nullable(new byte[] { 2, 0 })]
	private static List<ItemData> _preserveItems;

	[<1361eaae-87b4-45c8-8f26-e71396fe9fa4>Nullable(2)]
	private static Humanoid _target;

	private static bool _initialized;

	static EquipItemPatch()
	{
		if (!_initialized)
		{
			_initialized = true;
			UnityEngine.Debug.Log("[EquipItemPatch] \ud83d\udce6 Loaded EquipItemPatch.");
		}
	}

	public static bool Prefix(Humanoid __instance, ItemData item, bool triggerEquipEffects)
	{
		try
		{
			if ((UnityEngine.Object)(object)__instance == null)
			{
				return true;
			}
			if (item == null || item.m_shared == null)
			{
				return true;
			}
			Inventory inventory = __instance.GetInventory();
			if (inventory == null)
			{
				return true;
			}
			List<ItemData> equippedItems = inventory.GetEquippedItems();
			if (equippedItems == null || equippedItems.Count == 0)
			{
				return true;
			}
			string text = (SlotEquipContext.LastEquippedSlotType = GetSlotType(item));
			if (string.IsNullOrWhiteSpace(text))
			{
				return true;
			}
			List<ItemData> list = new List<ItemData>();
			foreach (ItemData item2 in equippedItems)
			{
				if (item2 != null && item2 != item && item2.m_shared != null)
				{
					string slotType = GetSlotType(item2);
					if (!string.IsNullOrEmpty(slotType) && !string.Equals(slotType, text, StringComparison.OrdinalIgnoreCase) && !item2.m_equipped)
					{
						list.Add(item2);
					}
				}
			}
			_preserveItems = list;
			_target = __instance;
		}
		catch (Exception arg)
		{
			UnityEngine.Debug.LogError($"[EquipItemPatch:Prefix] ❌ Exception: {arg}");
			_preserveItems = null;
			_target = null;
		}
		return true;
	}

	public static void Postfix()
	{
		try
		{
			if (_preserveItems == null || (UnityEngine.Object)(object)_target == null)
			{
				return;
			}
			foreach (ItemData preserveItem in _preserveItems)
			{
				if (preserveItem != null && !preserveItem.m_equipped)
				{
					_target.EquipItem(preserveItem, true);
				}
			}
		}
		catch (Exception arg)
		{
			UnityEngine.Debug.LogError($"[EquipItemPatch:Postfix] ❌ Exception: {arg}");
		}
		finally
		{
			_preserveItems = null;
			_target = null;
			SlotEquipContext.LastEquippedSlotType = null;
		}
	}

	private static string GetSlotType(ItemData item)
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Invalid comparison between Unknown and I4
		try
		{
			string slotType = SlotTypeRegistry.GetSlotType(item?.m_shared?.m_name?.TrimStart('$') ?? "");
			if (!string.IsNullOrEmpty(slotType))
			{
				return slotType;
			}
			if ((int)item.m_shared.m_itemType == 18)
			{
				return "Utility";
			}
			return "Unknown";
		}
		catch (Exception arg)
		{
			UnityEngine.Debug.LogError($"[EquipItemPatch:GetSlotType] ❌ Exception: {arg}");
			return "Unknown";
		}
	}
}
[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
public static class HumanoidUnequipItemPatch
{
	public static bool Prefix(Humanoid __instance, ItemData item, bool triggerEquipEffects)
	{
		if (item == null || item.m_shared == null)
		{
			return true;
		}
		string text = SlotTypeRegistry.GetSlotType(item.m_shared.m_name.TrimStart('$')) ?? "";
		string lastEquippedSlotType = SlotEquipContext.LastEquippedSlotType;
		if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(lastEquippedSlotType) && !text.Equals(lastEquippedSlotType, StringComparison.OrdinalIgnoreCase))
		{
			return false;
		}
		return true;
	}
}
public static class SlotDebugger
{
	public static void LogAllRegisteredSlots()
	{
		FieldInfo field = typeof(API).GetField("customSlots", BindingFlags.Static | BindingFlags.NonPublic);
		if (field == null)
		{
			UnityEngine.Debug.LogError("[SlotDebugger] ❌ Could not find 'customSlots' field in AzuEPI API.");
			return;
		}
		if (!(field.GetValue(null) is IDictionary dictionary))
		{
			UnityEngine.Debug.LogError("[SlotDebugger] ❌ 'customSlots' field was null or not a dictionary.");
			return;
		}
		foreach (DictionaryEntry item in dictionary)
		{
			string arg = item.Key.ToString();
			object value = item.Value;
			object arg2 = value.GetType().GetField("SlotIndex", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(value) ?? "Unknown";
			UnityEngine.Debug.Log($"[SlotDebugger] \ud83e\udde9 Slot: '{arg}' | Index: {arg2}");
		}
	}
}
public static class SlotEquipContext
{
	[<1361eaae-87b4-45c8-8f26-e71396fe9fa4>Nullable(2)]
	public static string LastEquippedSlotType;
}
public class SlotManager
{
	private class SlotDefinition
	{
		[JsonProperty("slot")]
		public string Slot { get; set; } = "";


		[JsonProperty("type")]
		public string Type { get; set; } = "";


		[JsonProperty("prefabs")]
		public List<string> Prefabs { get; set; } = new List<string>();

	}

	private const string SlotEndpoint = "https://api.einherjarslegacy.com/v1/api/get-quick-slots";

	private readonly List<SlotRegistrar> _registrars = new List<SlotRegistrar>();

	private static ManualLogSource logger;

	public void InitSlots(ManualLogSource _logger)
	{
		logger = _logger;
		try
		{
			using WebClient webClient = new WebClient();
			List<SlotDefinition> list = JsonConvert.DeserializeObject<List<SlotDefinition>>(webClient.DownloadString("https://api.einherjarslegacy.com/v1/api/get-quick-slots"));
			if (list == null)
			{
				return;
			}
			string[] slotNames = API.GetSlots().SlotNames;
			string[] array = slotNames;
			for (int i = 0; i < array.Length; i++)
			{
				_ = array[i];
			}
			for (int j = 0; j < slotNames.Length; j++)
			{
			}
			API.RemoveSlot("Utility");
			API.RemoveSlot("Backpack");
			foreach (SlotDefinition item in list)
			{
				foreach (string prefab in item.Prefabs)
				{
					SlotTypeRegistry.Register(prefab, item.Type);
				}
				SlotRegistrar slotRegistrar = new SlotRegistrar(item.Slot, item.Type, item.Prefabs);
				slotRegistrar.Register();
				_registrars.Add(slotRegistrar);
			}
			SlotDebugger.LogAllRegisteredSlots();
		}
		catch (Exception arg)
		{
			logger.LogError((object)$"[SlotManager] ❌ Exception during Init: {arg}");
		}
	}
}
public class SlotRegistrar
{
	private readonly string _slotName;

	private readonly string _slotType;

	private readonly HashSet<string> _validPrefabs;

	private static readonly HashSet<string> _alreadyLoggedMismatches = new HashSet<string>();

	private readonly HashSet<string> _loggedUnmatched = new HashSet<string>();

	public SlotRegistrar(string slotName, string slotType, IEnumerable<string> validPrefabNames)
	{
		_slotName = slotName;
		_slotType = slotType;
		_validPrefabs = new HashSet<string>(validPrefabNames.Select((string n) => n.ToLowerInvariant()), StringComparer.OrdinalIgnoreCase);
	}

	public void Register()
	{
		API.AddSlot(_slotName, (Func<Player, ItemData>)GetItemForSlot, (Func<ItemData, bool>)IsValidSlotItem, -1);
	}

	[return: <1361eaae-87b4-45c8-8f26-e71396fe9fa4>Nullable(2)]
	private ItemData GetItemForSlot(Humanoid player)
	{
		Inventory obj = ((player != null) ? player.GetInventory() : null);
		List<ItemData> list = ((obj != null) ? obj.GetEquippedItems() : null);
		if (list == null)
		{
			return null;
		}
		foreach (ItemData item2 in list)
		{
			if (item2 != null)
			{
				string item = (item2.m_shared?.m_name ?? "").TrimStart('$').ToLowerInvariant();
				if (_validPrefabs.Contains(item))
				{
					return item2;
				}
				if (!_alreadyLoggedMismatches.Contains(item))
				{
					_alreadyLoggedMismatches.Add(item);
				}
			}
		}
		return null;
	}

	[<42cac9b6-60e7-4f91-80b6-7f76cf32f091>NullableContext(2)]
	private bool IsValidSlotItem(ItemData item)
	{
		if (item == null || item.m_shared == null)
		{
			return false;
		}
		string item2 = (item.m_shared.m_name ?? "").TrimStart('$').ToLowerInvariant();
		bool num = _validPrefabs.Contains(item2);
		if (!num && !_loggedUnmatched.Contains(item2))
		{
			_loggedUnmatched.Add(item2);
		}
		return num;
	}
}
public static class SlotTypeRegistry
{
	private static readonly Dictionary<string, string> PrefabToSlotType = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

	public static void Register(string prefab, string slotType)
	{
		PrefabToSlotType[prefab.ToLowerInvariant()] = slotType;
	}

	[return: <1361eaae-87b4-45c8-8f26-e71396fe9fa4>Nullable(2)]
	public static string GetSlotType(string prefab)
	{
		PrefabToSlotType.TryGetValue(prefab.ToLowerInvariant(), out var value);
		return value;
	}
}
public static class TaskExtensions
{
	[CompilerGenerated]
	private sealed class <AsIEnumerator>d__0 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Task task;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <AsIEnumerator>d__0(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (!task.IsCompleted)
			{
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			if (task.Exception != null)
			{
				throw task.Exception;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[IteratorStateMachine(typeof(<AsIEnumerator>d__0))]
	public static IEnumerator AsIEnumerator(this Task task)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <AsIEnumerator>d__0(0)
		{
			task = task
		};
	}
}
namespace ViperModManagers.Utilities
{
	public static class StringExtensions
	{
		public static bool StringsAreEqual(this string first, string second)
		{
			return string.Equals(first, second, StringComparison.Ordinal);
		}

		public static bool ContainsAny(this string haystack, char needle)
		{
			return haystack.IndexOf(needle) > -1;
		}

		public static bool RemoveAny(this string haystack, string needle)
		{
			int num = haystack.IndexOf(needle);
			if (num > -1)
			{
				haystack.Remove(num);
				return true;
			}
			return false;
		}

		public static string TrimLastCharacter(string str)
		{
			if (string.IsNullOrEmpty(str))
			{
				return str;
			}
			return str.Substring(0, str.Length - 1);
		}

		public static string TrimNumberLastCharacter(string str, int times)
		{
			if (string.IsNullOrEmpty(str))
			{
				return str;
			}
			return str.Substring(0, str.Length - times);
		}

		public static string GetLast(this string source, int tail_length)
		{
			if (tail_length >= source.Length)
			{
				return source;
			}
			return source.Substring(source.Length - tail_length);
		}
	}
}
namespace ViperModManagers.ServerSide.Patches
{
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	internal static class Disconnect_Patch
	{
		[HarmonyPostfix]
		private static void Disconnect(ref ZNetPeer peer)
		{
			EventManager.RaisePlayerDisconnected(new Dictionary<string, object> { ["peer"] = peer });
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	internal static class OnNewConnection_Patch
	{
		[HarmonyPostfix]
		public static void OnConnect(ref ZNetPeer peer)
		{
			EventManager.RaisePlayerConnected(new Dictionary<string, object> { ["peer"] = peer });
		}
	}
}
namespace einherjars_client.Patches
{
	internal class ItemDropAwakePatch
	{
	}
}
namespace HelreidManagers
{
	[BepInPlugin("helreid.bepinex.plugins.einherjarslegacy", "EinherjarsLegacyClient", "1.1.1")]
	public class HelreidManager : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <WaitThenRegisterSlots>d__20 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public HelreidManager <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WaitThenRegisterSlots>d__20(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				HelreidManager helreidManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((BaseUnityPlugin)helreidManager).Logger.LogInfo((object)"⏳ Coroutine WaitThenRegisterSlots started...");
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((UnityEngine.Object)(object)ZNet.instance == null || (ZNet.instance.IsServer() && (UnityEngine.Object)(object)Player.m_localPlayer == null))
				{
					<>2__current = new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				}
				((BaseUnityPlugin)helreidManager).Logger.LogInfo((object)"✅ Server and player ready. Registering slots.");
				helreidManager._slotManager.InitSlots(((BaseUnityPlugin)helreidManager).Logger);
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public const string ModName = "EinherjarsLegacyClient";

		public const string ModVersion = "1.1.1";

		public const string ModGUID = "helreid.bepinex.plugins.einherjarslegacy";

		public const string DefaultLanguage = "English";

		public const string TranslationsFolderName = "translations";

		private CommonUtilities commonUtilities;

		private bool runLoader = true;

		private float elapsed;

		private bool coroutineRunning;

		private int tempCurrentDistantObjects;

		private int tempCurrentObjectsCount;

		private string tempZone;

		private SynchronizationContext mainContext;

		private string steamId;

		public Harmony harmony;

		private bool reloadItems;

		private string percentageDownload = "";

		private SlotManager _slotManager = new SlotManager();

		private Coroutine _slotInitCoroutine;

		public void Awake()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			PlayerPrefs.SetString("language", "English");
			mainContext = SynchronizationContext.Current;
			commonUtilities = new CommonUtilities();
			EventManager.OnLog += LogThis;
			TerritoryManager.LoadTerritoriesAsync();
			Assembly.GetExecutingAssembly();
			harmony = new Harmony("helreid.bepinex.plugins.einherjarslegacy");
			harmony.PatchAll();
			((MonoBehaviour)this).StartCoroutine(WaitThenRegisterSlots());
		}

		[IteratorStateMachine(typeof(<WaitThenRegisterSlots>d__20))]
		private IEnumerator WaitThenRegisterSlots()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitThenRegisterSlots>d__20(0)
			{
				<>4__this = this
			};
		}

		private void LogThis(Dictionary<string, object> args)
		{
			if (args.ContainsKey("message"))
			{
				string text = (string)args["message"];
				((BaseUnityPlugin)this).Logger.LogInfo((object)text);
			}
		}
	}
}
namespace Viper.Utilities
{
	public class CommonUtilities
	{
		public byte[] AddHeader(byte[] data)
		{
			byte[] bytes = BitConverter.GetBytes(data.Length);
			return CombineTwoArrays(bytes, data);
		}

		public byte[] CombineTwoArrays(byte[] first, byte[] second)
		{
			byte[] array = new byte[first.Length + second.Length];
			Buffer.BlockCopy(first, 0, array, 0, first.Length);
			Buffer.BlockCopy(second, 0, array, first.Length, second.Length);
			return array;
		}

		public byte[] Combine(params byte[][] arrays)
		{
			int num = 0;
			byte[][] array = arrays;
			foreach (byte[] array2 in array)
			{
				num += array2.Length;
			}
			byte[] array3 = new byte[num];
			int num2 = 0;
			array = arrays;
			foreach (byte[] array4 in array)
			{
				Buffer.BlockCopy(array4, 0, array3, num2, array4.Length);
				num2 += array4.Length;
			}
			return array3;
		}

		public bool EqualArrays(byte[] first, byte[] second)
		{
			if (first == null || second == null)
			{
				return false;
			}
			if (first.Length != second.Length)
			{
				return false;
			}
			for (int i = 0; i < first.Length; i++)
			{
				if (first[i] != second[i])
				{
					return false;
				}
			}
			return true;
		}

		public byte[] CombineWithFieldHeaders(params byte[][] arrays)
		{
			byte[] array = null;
			int num = 1;
			foreach (byte[] array2 in arrays)
			{
				byte[] bytes = BitConverter.GetBytes(array2.Length);
				byte[] array3 = CombineTwoArrays(bytes, array2);
				array = ((array != null) ? CombineTwoArrays(array, array3) : array3);
				num++;
			}
			return array;
		}

		public string SerializeLocalDictionary(Dictionary<string, object> args)
		{
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
				TypeNameHandling = TypeNameHandling.All
			};
			return JsonConvert.SerializeObject(args, settings);
		}

		public Dictionary<string, object> DeserializeLocalDictionary(string json)
		{
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
				TypeNameHandling = TypeNameHandling.All
			};
			return JsonConvert.DeserializeObject<Dictionary<string, object>>(json, settings);
		}

		public Dictionary<string, List<Dictionary<string, object>>> DeserializeLocalObject(string json)
		{
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
				TypeNameHandling = TypeNameHandling.All
			};
			return JsonConvert.DeserializeObject<Dictionary<string, List<Dictionary<string, object>>>>(json, settings);
		}

		public string[] DeserializeArray(string json)
		{
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
				TypeNameHandling = TypeNameHandling.All
			};
			return JsonConvert.DeserializeObject<string[]>(json, settings);
		}

		public byte[] SerializeDictionary(Dictionary<string, object> dictionary)
		{
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
				TypeNameHandling = TypeNameHandling.All
			};
			string s = JsonConvert.SerializeObject(dictionary, settings);
			byte[] bytes = Encoding.UTF8.GetBytes(s);
			using MemoryStream memoryStream = new MemoryStream();
			using (GZipStream gZipStream = new GZipStream(memoryStream, System.IO.Compression.CompressionLevel.Optimal))
			{
				gZipStream.Write(bytes, 0, bytes.Length);
			}
			return memoryStream.ToArray();
		}

		public Dictionary<string, object> DeserializeDictionary(byte[] compressedData)
		{
			using MemoryStream stream = new MemoryStream(compressedData);
			using GZipStream gZipStream = new GZipStream(stream, CompressionMode.Decompress);
			using MemoryStream memoryStream = new MemoryStream();
			byte[] array = new byte[4096];
			int num;
			do
			{
				num = gZipStream.Read(array, 0, array.Length);
				if (num > 0)
				{
					memoryStream.Write(array, 0, num);
				}
			}
			while (num > 0);
			byte[] bytes = memoryStream.ToArray();
			string @string = Encoding.UTF8.GetString(bytes);
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
				TypeNameHandling = TypeNameHandling.All
			};
			return JsonConvert.DeserializeObject<Dictionary<string, object>>(@string, settings);
		}

		public string SerializeLocalDictionaryString(Dictionary<string, string> args)
		{
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
				TypeNameHandling = TypeNameHandling.All
			};
			return JsonConvert.SerializeObject(args, settings);
		}

		public Dictionary<string, string> DeserializeLocalDictionaryString(string json)
		{
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
				TypeNameHandling = TypeNameHandling.All
			};
			return JsonConvert.DeserializeObject<Dictionary<string, string>>(json, settings);
		}

		public string SerializeLocalListDictionary(List<Dictionary<string, string>> args)
		{
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
				TypeNameHandling = TypeNameHandling.All
			};
			return JsonConvert.SerializeObject(args, settings);
		}

		public List<Dictionary<string, string>> DeserializeLocalStringListDictionary(string json)
		{
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
				TypeNameHandling = TypeNameHandling.All
			};
			return JsonConvert.DeserializeObject<List<Dictionary<string, string>>>(json, settings);
		}

		public string SerializeLocalToBase64DictionaryList(List<Dictionary<string, string>> args)
		{
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
				TypeNameHandling = TypeNameHandling.All
			};
			string s = JsonConvert.SerializeObject(args, settings);
			return Convert.ToBase64String(Encoding.UTF8.GetBytes(s));
		}

		public List<Dictionary<string, string>> DeserializeLocalToBase64DictionaryStringList(string base64json)
		{
			byte[] bytes = Convert.FromBase64String(base64json);
			string @string = Encoding.UTF8.GetString(bytes);
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
				TypeNameHandling = TypeNameHandling.All
			};
			return JsonConvert.DeserializeObject<List<Dictionary<string, string>>>(@string, settings);
		}

		public string SerializeLocalToBase64DictionaryString(Dictionary<string, string> args)
		{
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
				TypeNameHandling = TypeNameHandling.All
			};
			string s = JsonConvert.SerializeObject(args, settings);
			return Convert.ToBase64String(Encoding.UTF8.GetBytes(s));
		}

		public Dictionary<string, string> DeserializeLocalToBase64DictionaryString(string base64json)
		{
			byte[] bytes = Convert.FromBase64String(base64json);
			string @string = Encoding.UTF8.GetString(bytes);
			JsonSerializerSettings settings = new JsonSerializerSettings
			{
				TypeNameHandling = TypeNameHandling.All
			};
			return JsonConvert.DeserializeObject<Dictionary<string, string>>(@string, settings);
		}
	}
}
namespace Viper.Events
{
	public class EventManager
	{
		public delegate void PassDictionary(Dictionary<string, object> values);

		public delegate void PassDictionaryString(Dictionary<string, string> values);

		public delegate void PassDictionaryInt(Dictionary<int, object> values);

		public delegate void PassObject(object source);

		public delegate void PassNothing();

		public delegate void PassString(string value);

		public delegate void PassObjectDB(ObjectDB value);

		public delegate void PassZDO(ZDO zdo);

		public delegate void PassItemData(ItemData item);

		public static event PassObjectDB OnRegisterCustomData;

		public static event PassNothing OnReloadItems;

		public static event PassNothing OnPlayerSpawned;

		public static event PassNothing OnContinueQueue;

		public static event PassNothing OnApplyInventoryData;

		public static event PassNothing OnPlayerSelected;

		public static event PassNothing OnSupportAssetsLoaded;

		public static event PassNothing OnItemAssetsLoaded;

		public static event PassNothing OnPieceTableAssetsLoaded;

		public static event PassNothing OnMonsterAssetsLoaded;

		public static event PassNothing OnPrefabAssetsLoaded;

		public static event PassNothing OnSkillAssetsLoaded;

		public static event PassString OnReadyToReceive;

		public static event PassNothing OnQueueModsByCraftingTable;

		public static event PassZDO OnInvalidZDO;

		public static event PassDictionary OnNonSecureConnectionEstablished;

		public static event PassDictionary OnDataReceived;

		public static event PassDictionary OnSendNonSecureMessage;

		public static event PassDictionary OnConnectionLost;

		public static event PassDictionary OnLog;

		public static event PassDictionary OnCompleteFunc;

		public static event PassDictionary OnPlayerConnected;

		public static event PassDictionary OnSaveResource;

		public static event PassDictionary OnNotifyUser;

		public static event PassDictionary OnRegisterRequest;

		public static event PassDictionary OnDeactiveClientConnection;

		public static event PassDictionary OnCreateClientConnection;

		public static event PassDictionary OnPlayerDisconnected;

		public static event PassDictionaryString OnIncreaseSkill;

		public static event PassDictionary OnAddAssetBundle;

		public static event PassDictionary OnPlayerRegistered;

		public static event PassDictionary OnRetrievedAlchemy;

		public static event PassDictionary OnAssetBundleRetrieved;

		public static event PassDictionary OnGetAllZDOsWithPrefabIterative;

		public static event PassDictionary OnCreatedObjectsSorted;

		public static event PassDictionary OnBiomeAssetBundlesRetrieved;

		public static event PassDictionary OnDelayInvalidPrefabRemoval;

		public static event PassDictionary OnQueueItemReload;

		public static event PassDictionary OnModReceived;

		public static event PassDictionary OnGetBiomeModsResponse;

		public static event PassDictionary OnDisplayPercentage;

		public static event PassDictionary OnGetAndDownloadMod;

		public static event PassDictionary OnSendRetrievedModsToClient;

		public static event PassDictionary OnRecordPlayerPlacedCustomTable;

		public static event PassDictionary OnRemovePlayerPlacedCustomTable;

		public static event PassDictionary OnSetPlayerCustomData;

		public static event PassDictionary OnApplyPlayerCustomData;

		public static event PassDictionaryString OnRaiseAlchemy;

		public static event PassDictionaryString OnRemoveSkillDataFromCustomData;

		public static event PassDictionaryString OnUpdateSkillDataToCustomData;

		public static event PassString OnConfigLoaded;

		public static event PassString OnAddPlaceholder;

		public static event PassString OnQueueModRetrieval;

		public static event PassString OnQueueItemForModRetrieval;

		public static event PassString OnProcessNewAssets;

		public static event PassString OnApplySkillData;

		public static event PassString OnApplySkills;

		public static void RaiseApplyCustomData(Dictionary<string, object> args)
		{
			if (EventManager.OnApplyPlayerCustomData != null)
			{
				EventManager.OnApplyPlayerCustomData(args);
			}
		}

		public static void RaiseSetCustomData(Dictionary<string, object> args)
		{
			if (EventManager.OnSetPlayerCustomData != null)
			{
				EventManager.OnSetPlayerCustomData(args);
			}
		}

		public static void RaiseSendRetrievedModsToClient(Dictionary<string, object> args)
		{
			if (EventManager.OnSendRetrievedModsToClient != null)
			{
				EventManager.OnSendRetrievedModsToClient(args);
			}
		}

		public static void RaiseGetAndDownloadMod(Dictionary<string, object> args)
		{
			if (EventManager.OnGetAndDownloadMod != null)
			{
				EventManager.OnGetAndDownloadMod(args);
			}
		}

		public static void RaiseDisplayPercentage(Dictionary<string, object> args)
		{
			if (EventManager.OnDisplayPercentage != null)
			{
				EventManager.OnDisplayPercentage(args);
			}
		}

		public static void RaiseGetBiomeModsResponse(Dictionary<string, object> args)
		{
			if (EventManager.OnGetBiomeModsResponse != null)
			{
				EventManager.OnGetBiomeModsResponse(args);
			}
		}

		public static void RaiseModReceived(Dictionary<string, object> args)
		{
			if (EventManager.OnModReceived != null)
			{
				EventManager.OnModReceived(args);
			}
		}

		public static void RaiseQueueItemForModRetrieval(string itemName)
		{
			if (EventManager.OnQueueItemForModRetrieval != null)
			{
				EventManager.OnQueueItemForModRetrieval(itemName);
			}
		}

		public static void RaiseQueueModRetrieval(string modName)
		{
			if (EventManager.OnQueueModRetrieval != null)
			{
				EventManager.OnQueueModRetrieval(modName);
			}
		}

		public static void RaiseProcessNewAssets(string modName)
		{
			if (EventManager.OnProcessNewAssets != null)
			{
				EventManager.OnProcessNewAssets(modName);
			}
		}

		public static void RaiseQueueItemReload(Dictionary<string, object> args)
		{
			if (EventManager.OnQueueItemReload != null)
			{
				EventManager.OnQueueItemReload(args);
			}
		}

		public static void RaiseRaiseAlchemy(Dictionary<string, string> args)
		{
			if (EventManager.OnRaiseAlchemy != null)
			{
				EventManager.OnRaiseAlchemy(args);
			}
		}

		public static void RaiseReadyToReceive(string steamId)
		{
			if (EventManager.OnReadyToReceive != null)
			{
				EventManager.OnReadyToReceive(steamId);
			}
		}

		public static void RaiseItemAssetsLoaded()
		{
			if (EventManager.OnItemAssetsLoaded != null)
			{
				EventManager.OnItemAssetsLoaded();
			}
		}

		public static void RaisePieceTableAssetsLoaded()
		{
			if (EventManager.OnPieceTableAssetsLoaded != null)
			{
				EventManager.OnPieceTableAssetsLoaded();
			}
		}

		public static void RaiseMonsterAssetsLoaded()
		{
			if (EventManager.OnMonsterAssetsLoaded != null)
			{
				EventManager.OnMonsterAssetsLoaded();
			}
		}

		public static void RaisePrefabAssetsLoaded()
		{
			if (EventManager.OnPrefabAssetsLoaded != null)
			{
				EventManager.OnPrefabAssetsLoaded();
			}
		}

		public static void RaiseSupportAssetsLoaded()
		{
			if (EventManager.OnSupportAssetsLoaded != null)
			{
				EventManager.OnSupportAssetsLoaded();
			}
		}

		public static void RaisePlayerSelected()
		{
			if (EventManager.OnPlayerSelected != null)
			{
				EventManager.OnPlayerSelected();
			}
		}

		public static void RaiseApplyInventoryData()
		{
			if (EventManager.OnApplyInventoryData != null)
			{
				EventManager.OnApplyInventoryData();
			}
		}

		public static void RaiseApplySkillData(string skillName)
		{
			if (EventManager.OnApplySkillData != null)
			{
				EventManager.OnApplySkillData(skillName);
			}
		}

		public static void RaiseRemoveSkillDataFromCustomData(Dictionary<string, string> args)
		{
			if (EventManager.OnRemoveSkillDataFromCustomData != null)
			{
				EventManager.OnRemoveSkillDataFromCustomData(args);
			}
		}

		public static void RaiseUpdateSkillDataToCustomData(Dictionary<string, string> args)
		{
			if (EventManager.OnUpdateSkillDataToCustomData != null)
			{
				EventManager.OnUpdateSkillDataToCustomData(args);
			}
		}

		public static void RaiseDelayInvalidPrefabRemoval(Dictionary<string, object> args)
		{
			if (EventManager.OnDelayInvalidPrefabRemoval != null)
			{
				EventManager.OnDelayInvalidPrefabRemoval(args);
			}
		}

		public static void RaiseBiomeAssetBundlesRetrieved(Dictionary<string, object> args)
		{
			if (EventManager.OnBiomeAssetBundlesRetrieved != null)
			{
				EventManager.OnBiomeAssetBundlesRetrieved(args);
			}
		}

		public static void RaiseCreatedObjectsSorted(Dictionary<string, object> args)
		{
			if (EventManager.OnCreatedObjectsSorted != null)
			{
				EventManager.OnCreatedObjectsSorted(args);
			}
		}

		public static void RaiseGetAllZDOsWithPrefabIterative(Dictionary<string, object> args)
		{
			if (EventManager.OnGetAllZDOsWithPrefabIterative != null)
			{
				EventManager.OnGetAllZDOsWithPrefabIterative(args);
			}
		}

		public static void RaiseInvalidZDO(ZDO zdo)
		{
			if (EventManager.OnInvalidZDO != null)
			{
				EventManager.OnInvalidZDO(zdo);
			}
		}

		public static void RaiseAssetBundleRetrieved(Dictionary<string, object> args)
		{
			if (EventManager.OnAssetBundleRetrieved != null)
			{
				EventManager.OnAssetBundleRetrieved(args);
			}
		}

		public static void RaiseRegisterCustomData(ObjectDB args)
		{
			if (EventManager.OnRegisterCustomData != null)
			{
				EventManager.OnRegisterCustomData(args);
			}
		}

		public static void RaiseRetrievedAlchemy(Dictionary<string, object> args)
		{
			if (EventManager.OnRetrievedAlchemy != null)
			{
				EventManager.OnRetrievedAlchemy(args);
			}
		}

		public static void RaisePlayerRegistered(Dictionary<string, object> args)
		{
			if (EventManager.OnPlayerRegistered != null)
			{
				EventManager.OnPlayerRegistered(args);
			}
		}

		public static void RaisePlayerSpawned()
		{
			if (EventManager.OnPlayerSpawned != null)
			{
				EventManager.OnPlayerSpawned();
			}
		}

		public static void RaiseContinueQueue()
		{
			if (EventManager.OnContinueQueue != null)
			{
				EventManager.OnContinueQueue();
			}
		}

		public static void RaiseAddAssetBundle(Dictionary<string, object> args)
		{
			if (EventManager.OnAddAssetBundle != null)
			{
				EventManager.OnAddAssetBundle(args);
			}
		}

		public static void RaiseAddPlaceholder(string arg)
		{
			if (EventManager.OnAddPlaceholder != null)
			{
				EventManager.OnAddPlaceholder(arg);
			}
		}

		public static void RaiseConfigLoaded(string arg)
		{
			if (EventManager.OnConfigLoaded != null)
			{
				EventManager.OnConfigLoaded(arg);
			}
		}

		public static void RaiseReloadItems()
		{
			if (EventManager.OnReloadItems != null)
			{
				EventManager.OnReloadItems();
			}
		}

		public static void RaiseApplySkills(string skillName)
		{
			if (EventManager.OnApplySkills != null)
			{
				EventManager.OnApplySkills(skillName);
			}
		}

		public static void RaiseCompleteFunc(Dictionary<string, object> args)
		{
			if (EventManager.OnCompleteFunc != null)
			{
				EventManager.OnCompleteFunc(args);
			}
		}

		public static void RaiseLog(Dictionary<string, object> args)
		{
			if (EventManager.OnLog != null)
			{
				EventManager.OnLog(args);
			}
		}

		public static void RaiseDeactiveClientConnection(Dictionary<string, object> args)
		{
			if (EventManager.OnDeactiveClientConnection != null)
			{
				EventManager.OnDeactiveClientConnection(args);
			}
		}

		public static void RaiseCreateClientConnection(Dictionary<string, object> args)
		{
			if (EventManager.OnCreateClientConnection != null)
			{
				EventManager.OnCreateClientConnection(args);
			}
		}

		public static void RaiseRegisterRequest(Dictionary<string, object> args)
		{
			if (EventManager.OnRegisterRequest != null)
			{
				EventManager.OnRegisterRequest(args);
			}
		}

		public static void RaiseNotifyUser(Dictionary<string, object> args)
		{
			if (EventManager.OnNotifyUser != null)
			{
				EventManager.OnNotifyUser(args);
			}
		}

		public static void RaiseSaveResource(Dictionary<string, object> args)
		{
			if (EventManager.OnSaveResource != null)
			{
				EventManager.OnSaveResource(args);
			}
		}

		public static void RaisePlayerConnected(Dictionary<string, object> args)
		{
			if (EventManager.OnPlayerConnected != null)
			{
				EventManager.OnPlayerConnected(args);
			}
		}

		public static void RaisePlayerDisconnected(Dictionary<string, object> args)
		{
			if (EventManager.OnPlayerDisconnected != null)
			{
				EventManager.OnPlayerDisconnected(args);
			}
		}

		public static void RaiseNonSecureConnectionEstablished(Dictionary<string, object> args)
		{
			if (EventManager.OnNonSecureConnectionEstablished != null)
			{
				EventManager.OnNonSecureConnectionEstablished(args);
			}
		}

		public static void RaiseDataReceived(Dictionary<string, object> args)
		{
			if (EventManager.OnDataReceived != null)
			{
				EventManager.OnDataReceived(args);
			}
		}

		public static void RaiseSendNonSecureMessage(Dictionary<string, object> args)
		{
			if (EventManager.OnSendNonSecureMessage != null)
			{
				EventManager.OnSendNonSecureMessage(args);
			}
		}

		public static void RaiseConnectionLost(Dictionary<string, object> args)
		{
			if (EventManager.OnConnectionLost != null)
			{
				EventManager.OnConnectionLost(args);
			}
		}
	}
}
namespace TerritoryStars
{
	public class MarketplaceTerritory
	{
		public string Name;

		public string X;

		public string Z;

		public string Radius;

		[JsonProperty("add_stars")]
		public int AddStars;

		public UnityEngine.Vector3 Center => new UnityEngine.Vector3(float.Parse(X, CultureInfo.InvariantCulture), 0f, float.Parse(Z, CultureInfo.InvariantCulture));

		public float RadiusValue
		{
			get
			{
				if (!float.TryParse(Radius, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					return 0f;
				}
				return result;
			}
		}
	}
	public static class TerritoryManager
	{
		private static readonly string endpoint = "https://api.einherjarslegacy.com/v1/api/get-territories";

		private static CancellationTokenSource _cts = new CancellationTokenSource();

		private static bool _started = false;

		public static List<MarketplaceTerritory> Territories { get; private set; } = new List<MarketplaceTerritory>();


		public static async Task LoadTerritoriesAsync()
		{
			_ = 1;
			try
			{
				HttpClient client = new HttpClient();
				try
				{
					HttpResponseMessage val = await client.GetAsync(endpoint);
					if (!val.IsSuccessStatusCode)
					{
						UnityEngine.Debug.LogError($"[TerritoryStars] ❌ Failed to fetch territories: {val.StatusCode}");
						return;
					}
					Territories = JsonConvert.DeserializeObject<List<MarketplaceTerritory>>(await val.Content.ReadAsStringAsync()) ?? new List<MarketplaceTerritory>();
					UnityEngine.Debug.Log($"[TerritoryStars] ✅ Loaded {Territories.Count} territories.");
				}
				finally
				{
					((IDisposable)client)?.Dispose();
				}
			}
			catch (Exception arg)
			{
				UnityEngine.Debug.LogError($"[TerritoryStars] ❌ Exception while loading territories: {arg}");
			}
		}

		public static MarketplaceTerritory GetTerritoryAt(UnityEngine.Vector3 position)
		{
			foreach (MarketplaceTerritory territory in Territories)
			{
				UnityEngine.Vector2 a = new UnityEngine.Vector2(position.x, position.z);
				UnityEngine.Vector2 b = new UnityEngine.Vector2(territory.Center.x, territory.Center.z);
				if (UnityEngine.Vector2.Distance(a, b) <= territory.RadiusValue && territory.AddStars > 0)
				{
					return territory;
				}
			}
			return null;
		}

		public static void StartAutoRefresh()
		{
			if (_started)
			{
				return;
			}
			_started = true;
			Task.Run(async delegate
			{
				while (!_cts.IsCancellationRequested)
				{
					await LoadTerritoriesAsync();
					await Task.Delay(TimeSpan.FromMinutes(2.0), _cts.Token);
				}
			});
		}

		public static void StopAutoRefresh()
		{
			_cts.Cancel();
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<e2c80ee8-79ca-4337-a0d1-af10822f4128>Embedded]
	internal sealed class <e2c80ee8-79ca-4337-a0d1-af10822f4128>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[<e2c80ee8-79ca-4337-a0d1-af10822f4128>Embedded]
	[CompilerGenerated]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[<e2c80ee8-79ca-4337-a0d1-af10822f4128>Embedded]
	internal sealed class <94d2f417-f14b-4d6a-990c-aabc0b494c9f>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <94d2f417-f14b-4d6a-990c-aabc0b494c9f>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <94d2f417-f14b-4d6a-990c-aabc0b494c9f>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[<e2c80ee8-79ca-4337-a0d1-af10822f4128>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <54df5b1c-9970-400c-9dde-f1e30852f343>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <54df5b1c-9970-400c-9dde-f1e30852f343>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true)]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
	internal sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal class DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
}
namespace Newtonsoft.Json
{
	internal enum ConstructorHandling
	{
		Default,
		AllowNonPublicDefaultConstructor
	}
	internal enum DateFormatHandling
	{
		IsoDateFormat,
		MicrosoftDateFormat
	}
	internal enum DateParseHandling
	{
		None,
		DateTime,
		DateTimeOffset
	}
	internal enum DateTimeZoneHandling
	{
		Local,
		Utc,
		Unspecified,
		RoundtripKind
	}
	[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(0)]
	[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
	internal class DefaultJsonNameTable : JsonNameTable
	{
		[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(0)]
		private class Entry
		{
			internal readonly string Value;

			internal readonly int HashCode;

			internal Entry Next;

			internal Entry(string value, int hashCode, Entry next)
			{
				Value = value;
				HashCode = hashCode;
				Next = next;
			}
		}

		private static readonly int HashCodeRandomizer;

		private int _count;

		private Entry[] _entries;

		private int _mask = 31;

		static DefaultJsonNameTable()
		{
			HashCodeRandomizer = Environment.TickCount;
		}

		public DefaultJsonNameTable()
		{
			_entries = new Entry[_mask + 1];
		}

		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		public override string Get(char[] key, int start, int length)
		{
			if (length == 0)
			{
				return string.Empty;
			}
			int num = length + HashCodeRandomizer;
			num += (num << 7) ^ key[start];
			int num2 = start + length;
			for (int i = start + 1; i < num2; i++)
			{
				num += (num << 7) ^ key[i];
			}
			num -= num >> 17;
			num -= num >> 11;
			num -= num >> 5;
			int num3 = Volatile.Read(ref _mask);
			int num4 = num & num3;
			for (Entry entry = _entries[num4]; entry != null; entry = entry.Next)
			{
				if (entry.HashCode == num && TextEquals(entry.Value, key, start, length))
				{
					return entry.Value;
				}
			}
			return null;
		}

		public string Add(string key)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			int length = key.Length;
			if (length == 0)
			{
				return string.Empty;
			}
			int num = length + HashCodeRandomizer;
			for (int i = 0; i < key.Length; i++)
			{
				num += (num << 7) ^ key[i];
			}
			num -= num >> 17;
			num -= num >> 11;
			num -= num >> 5;
			for (Entry entry = _entries[num & _mask]; entry != null; entry = entry.Next)
			{
				if (entry.HashCode == num && entry.Value.Equals(key, StringComparison.Ordinal))
				{
					return entry.Value;
				}
			}
			return AddEntry(key, num);
		}

		private string AddEntry(string str, int hashCode)
		{
			int num = hashCode & _mask;
			Entry entry = new Entry(str, hashCode, _entries[num]);
			_entries[num] = entry;
			if (_count++ == _mask)
			{
				Grow();
			}
			return entry.Value;
		}

		private void Grow()
		{
			Entry[] entries = _entries;
			int num = _mask * 2 + 1;
			Entry[] array = new Entry[num + 1];
			for (int i = 0; i < entries.Length; i++)
			{
				Entry entry = entries[i];
				while (entry != null)
				{
					int num2 = entry.HashCode & num;
					Entry next = entry.Next;
					entry.Next = array[num2];
					array[num2] = entry;
					entry = next;
				}
			}
			_entries = array;
			Volatile.Write(ref _mask, num);
		}

		private static bool TextEquals(string str1, char[] str2, int str2Start, int str2Length)
		{
			if (str1.Length != str2Length)
			{
				return false;
			}
			for (int i = 0; i < str1.Length; i++)
			{
				if (str1[i] != str2[str2Start + i])
				{
					return false;
				}
			}
			return true;
		}
	}
	[Flags]
	internal enum DefaultValueHandling
	{
		Include = 0,
		Ignore = 1,
		Populate = 2,
		IgnoreAndPopulate = 3
	}
	internal enum FloatFormatHandling
	{
		String,
		Symbol,
		DefaultValue
	}
	internal enum FloatParseHandling
	{
		Double,
		Decimal
	}
	internal enum Formatting
	{
		None,
		Indented
	}
	[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
	internal interface IArrayPool<[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] T>
	{
		T[] Rent(int minimumLength);

		void Return([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })] T[] array);
	}
	internal interface IJsonLineInfo
	{
		int LineNumber { get; }

		int LinePosition { get; }

		bool HasLineInfo();
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
	internal sealed class JsonArrayAttribute : JsonContainerAttribute
	{
		private bool _allowNullItems;

		public bool AllowNullItems
		{
			get
			{
				return _allowNullItems;
			}
			set
			{
				_allowNullItems = value;
			}
		}

		public JsonArrayAttribute()
		{
		}

		public JsonArrayAttribute(bool allowNullItems)
		{
			_allowNullItems = allowNullItems;
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		public JsonArrayAttribute(string id)
			: base(id)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false)]
	internal sealed class JsonConstructorAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
	[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(0)]
	[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
	internal abstract class JsonContainerAttribute : Attribute
	{
		internal bool? _isReference;

		internal bool? _itemIsReference;

		internal ReferenceLoopHandling? _itemReferenceLoopHandling;

		internal TypeNameHandling? _itemTypeNameHandling;

		private Type _namingStrategyType;

		[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
		private object[] _namingStrategyParameters;

		public string Id { get; set; }

		public string Title { get; set; }

		public string Description { get; set; }

		public Type ItemConverterType { get; set; }

		[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
		[field: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
		public object[] ItemConverterParameters
		{
			[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
			get;
			[param: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
			set;
		}

		public Type NamingStrategyType
		{
			get
			{
				return _namingStrategyType;
			}
			set
			{
				_namingStrategyType = value;
				NamingStrategyInstance = null;
			}
		}

		[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
		public object[] NamingStrategyParameters
		{
			[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
			get
			{
				return _namingStrategyParameters;
			}
			[param: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
			set
			{
				_namingStrategyParameters = value;
				NamingStrategyInstance = null;
			}
		}

		internal NamingStrategy NamingStrategyInstance { get; set; }

		public bool IsReference
		{
			get
			{
				return _isReference.GetValueOrDefault();
			}
			set
			{
				_isReference = value;
			}
		}

		public bool ItemIsReference
		{
			get
			{
				return _itemIsReference.GetValueOrDefault();
			}
			set
			{
				_itemIsReference = value;
			}
		}

		public ReferenceLoopHandling ItemReferenceLoopHandling
		{
			get
			{
				return _itemReferenceLoopHandling.GetValueOrDefault();
			}
			set
			{
				_itemReferenceLoopHandling = value;
			}
		}

		public TypeNameHandling ItemTypeNameHandling
		{
			get
			{
				return _itemTypeNameHandling.GetValueOrDefault();
			}
			set
			{
				_itemTypeNameHandling = value;
			}
		}

		protected JsonContainerAttribute()
		{
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		protected JsonContainerAttribute(string id)
		{
			Id = id;
		}
	}
	[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(0)]
	[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
	internal static class JsonConvert
	{
		public static readonly string True = "true";

		public static readonly string False = "false";

		public static readonly string Null = "null";

		public static readonly string Undefined = "undefined";

		public static readonly string PositiveInfinity = "Infinity";

		public static readonly string NegativeInfinity = "-Infinity";

		public static readonly string NaN = "NaN";

		[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
		[field: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
		public static Func<JsonSerializerSettings> DefaultSettings
		{
			[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
			get;
			[param: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
			set;
		}

		public static string ToString(DateTime value)
		{
			return ToString(value, DateFormatHandling.IsoDateFormat, DateTimeZoneHandling.RoundtripKind);
		}

		public static string ToString(DateTime value, DateFormatHandling format, DateTimeZoneHandling timeZoneHandling)
		{
			DateTime value2 = DateTimeUtils.EnsureDateTime(value, timeZoneHandling);
			using StringWriter stringWriter = StringUtils.CreateStringWriter(64);
			stringWriter.Write('"');
			DateTimeUtils.WriteDateTimeString(stringWriter, value2, format, null, CultureInfo.InvariantCulture);
			stringWriter.Write('"');
			return stringWriter.ToString();
		}

		public static string ToString(DateTimeOffset value)
		{
			return ToString(value, DateFormatHandling.IsoDateFormat);
		}

		public static string ToString(DateTimeOffset value, DateFormatHandling format)
		{
			using StringWriter stringWriter = StringUtils.CreateStringWriter(64);
			stringWriter.Write('"');
			DateTimeUtils.WriteDateTimeOffsetString(stringWriter, value, format, null, CultureInfo.InvariantCulture);
			stringWriter.Write('"');
			return stringWriter.ToString();
		}

		public static string ToString(bool value)
		{
			if (!value)
			{
				return False;
			}
			return True;
		}

		public static string ToString(char value)
		{
			return ToString(char.ToString(value));
		}

		public static string ToString(Enum value)
		{
			return value.ToString("D");
		}

		public static string ToString(int value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		public static string ToString(short value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		[CLSCompliant(false)]
		public static string ToString(ushort value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		[CLSCompliant(false)]
		public static string ToString(uint value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		public static string ToString(long value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		private static string ToStringInternal(BigInteger value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		[CLSCompliant(false)]
		public static string ToString(ulong value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		public static string ToString(float value)
		{
			return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
		}

		internal static string ToString(float value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
		{
			return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable);
		}

		private static string EnsureFloatFormat(double value, string text, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
		{
			if (floatFormatHandling == FloatFormatHandling.Symbol || (!double.IsInfinity(value) && !double.IsNaN(value)))
			{
				return text;
			}
			if (floatFormatHandling == FloatFormatHandling.DefaultValue)
			{
				if (nullable)
				{
					return Null;
				}
				return "0.0";
			}
			return quoteChar + text + quoteChar;
		}

		public static string ToString(double value)
		{
			return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
		}

		internal static string ToString(double value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
		{
			return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable);
		}

		private static string EnsureDecimalPlace(double value, string text)
		{
			if (double.IsNaN(value) || double.IsInfinity(value) || StringUtils.IndexOf(text, '.') != -1 || StringUtils.IndexOf(text, 'E') != -1 || StringUtils.IndexOf(text, 'e') != -1)
			{
				return text;
			}
			return text + ".0";
		}

		private static string EnsureDecimalPlace(string text)
		{
			if (StringUtils.IndexOf(text, '.') != -1)
			{
				return text;
			}
			return text + ".0";
		}

		public static string ToString(byte value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		[CLSCompliant(false)]
		public static string ToString(sbyte value)
		{
			return value.ToString(null, CultureInfo.InvariantCulture);
		}

		public static string ToString(decimal value)
		{
			return EnsureDecimalPlace(value.ToString(null, CultureInfo.InvariantCulture));
		}

		public static string ToString(Guid value)
		{
			return ToString(value, '"');
		}

		internal static string ToString(Guid value, char quoteChar)
		{
			string text = value.ToString("D", CultureInfo.InvariantCulture);
			string text2 = quoteChar.ToString(CultureInfo.InvariantCulture);
			return text2 + text + text2;
		}

		public static string ToString(TimeSpan value)
		{
			return ToString(value, '"');
		}

		internal static string ToString(TimeSpan value, char quoteChar)
		{
			return ToString(value.ToString(), quoteChar);
		}

		public static string ToString([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] Uri value)
		{
			if (value == null)
			{
				return Null;
			}
			return ToString(value, '"');
		}

		internal static string ToString(Uri value, char quoteChar)
		{
			return ToString(value.OriginalString, quoteChar);
		}

		public static string ToString([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] string value)
		{
			return ToString(value, '"');
		}

		public static string ToString([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] string value, char delimiter)
		{
			return ToString(value, delimiter, StringEscapeHandling.Default);
		}

		public static string ToString([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] string value, char delimiter, StringEscapeHandling stringEscapeHandling)
		{
			if (delimiter != '"' && delimiter != '\'')
			{
				throw new ArgumentException("Delimiter must be a single or double quote.", "delimiter");
			}
			return JavaScriptUtils.ToEscapedJavaScriptString(value, delimiter, appendDelimiters: true, stringEscapeHandling);
		}

		public static string ToString([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] object value)
		{
			if (value == null)
			{
				return Null;
			}
			return ConvertUtils.GetTypeCode(value.GetType()) switch
			{
				PrimitiveTypeCode.String => ToString((string)value), 
				PrimitiveTypeCode.Char => ToString((char)value), 
				PrimitiveTypeCode.Boolean => ToString((bool)value), 
				PrimitiveTypeCode.SByte => ToString((sbyte)value), 
				PrimitiveTypeCode.Int16 => ToString((short)value), 
				PrimitiveTypeCode.UInt16 => ToString((ushort)value), 
				PrimitiveTypeCode.Int32 => ToString((int)value), 
				PrimitiveTypeCode.Byte => ToString((byte)value), 
				PrimitiveTypeCode.UInt32 => ToString((uint)value), 
				PrimitiveTypeCode.Int64 => ToString((long)value), 
				PrimitiveTypeCode.UInt64 => ToString((ulong)value), 
				PrimitiveTypeCode.Single => ToString((float)value), 
				PrimitiveTypeCode.Double => ToString((double)value), 
				PrimitiveTypeCode.DateTime => ToString((DateTime)value), 
				PrimitiveTypeCode.Decimal => ToString((decimal)value), 
				PrimitiveTypeCode.DBNull => Null, 
				PrimitiveTypeCode.DateTimeOffset => ToString((DateTimeOffset)value), 
				PrimitiveTypeCode.Guid => ToString((Guid)value), 
				PrimitiveTypeCode.Uri => ToString((Uri)value), 
				PrimitiveTypeCode.TimeSpan => ToString((TimeSpan)value), 
				PrimitiveTypeCode.BigInteger => ToStringInternal((BigInteger)value), 
				_ => throw new ArgumentException("Unsupported type: {0}. Use the JsonSerializer class to get the object's JSON representation.".FormatWith(CultureInfo.InvariantCulture, value.GetType())), 
			};
		}

		[DebuggerStepThrough]
		public static string SerializeObject([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] object value)
		{
			return SerializeObject(value, (Type)null, (JsonSerializerSettings)null);
		}

		[DebuggerStepThrough]
		public static string SerializeObject([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] object value, Formatting formatting)
		{
			return SerializeObject(value, formatting, (JsonSerializerSettings)null);
		}

		[DebuggerStepThrough]
		public static string SerializeObject([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] object value, params JsonConverter[] converters)
		{
			JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
			{
				Converters = converters
			} : null);
			return SerializeObject(value, null, settings);
		}

		[DebuggerStepThrough]
		public static string SerializeObject([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] object value, Formatting formatting, params JsonConverter[] converters)
		{
			JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
			{
				Converters = converters
			} : null);
			return SerializeObject(value, null, formatting, settings);
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
		[DebuggerStepThrough]
		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)]
		public static string SerializeObject(object value, JsonSerializerSettings settings)
		{
			return SerializeObject(value, null, settings);
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
		[DebuggerStepThrough]
		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)]
		public static string SerializeObject(object value, Type type, JsonSerializerSettings settings)
		{
			JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
			return SerializeObjectInternal(value, type, jsonSerializer);
		}

		[DebuggerStepThrough]
		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)]
		public static string SerializeObject(object value, Formatting formatting, JsonSerializerSettings settings)
		{
			return SerializeObject(value, null, formatting, settings);
		}

		[DebuggerStepThrough]
		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)]
		public static string SerializeObject(object value, Type type, Formatting formatting, JsonSerializerSettings settings)
		{
			JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
			jsonSerializer.Formatting = formatting;
			return SerializeObjectInternal(value, type, jsonSerializer);
		}

		private static string SerializeObjectInternal([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] object value, [<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] Type type, JsonSerializer jsonSerializer)
		{
			StringWriter stringWriter = new StringWriter(new StringBuilder(256), CultureInfo.InvariantCulture);
			using (JsonTextWriter jsonTextWriter = new JsonTextWriter(stringWriter))
			{
				jsonTextWriter.Formatting = jsonSerializer.Formatting;
				jsonSerializer.Serialize(jsonTextWriter, value, type);
			}
			return stringWriter.ToString();
		}

		[DebuggerStepThrough]
		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		public static object DeserializeObject(string value)
		{
			return DeserializeObject(value, (Type)null, (JsonSerializerSettings)null);
		}

		[DebuggerStepThrough]
		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		public static object DeserializeObject(string value, JsonSerializerSettings settings)
		{
			return DeserializeObject(value, null, settings);
		}

		[DebuggerStepThrough]
		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		public static object DeserializeObject(string value, Type type)
		{
			return DeserializeObject(value, type, (JsonSerializerSettings)null);
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
		[DebuggerStepThrough]
		public static T DeserializeObject<T>([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)] string value)
		{
			return JsonConvert.DeserializeObject<T>(value, (JsonSerializerSettings)null);
		}

		[DebuggerStepThrough]
		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		public static T DeserializeAnonymousType<[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] T>(string value, T anonymousTypeObject)
		{
			return DeserializeObject<T>(value);
		}

		[DebuggerStepThrough]
		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		public static T DeserializeAnonymousType<[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] T>(string value, T anonymousTypeObject, JsonSerializerSettings settings)
		{
			return DeserializeObject<T>(value, settings);
		}

		[DebuggerStepThrough]
		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		public static T DeserializeObject<[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] T>(string value, params JsonConverter[] converters)
		{
			return (T)DeserializeObject(value, typeof(T), converters);
		}

		[DebuggerStepThrough]
		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
		public static T DeserializeObject<T>([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)] string value, JsonSerializerSettings settings)
		{
			return (T)DeserializeObject(value, typeof(T), settings);
		}

		[DebuggerStepThrough]
		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		public static object DeserializeObject(string value, Type type, params JsonConverter[] converters)
		{
			JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
			{
				Converters = converters
			} : null);
			return DeserializeObject(value, type, settings);
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
		public static object DeserializeObject([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)] string value, Type type, JsonSerializerSettings settings)
		{
			ValidationUtils.ArgumentNotNull(value, "value");
			JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
			if (!jsonSerializer.IsCheckAdditionalContentSet())
			{
				jsonSerializer.CheckAdditionalContent = true;
			}
			using JsonTextReader reader = new JsonTextReader(new StringReader(value));
			return jsonSerializer.Deserialize(reader, type);
		}

		[DebuggerStepThrough]
		public static void PopulateObject(string value, object target)
		{
			PopulateObject(value, target, null);
		}

		public static void PopulateObject(string value, object target, [<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] JsonSerializerSettings settings)
		{
			JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
			using JsonReader jsonReader = new JsonTextReader(new StringReader(value));
			jsonSerializer.Populate(jsonReader, target);
			if (settings == null || !settings.CheckAdditionalContent)
			{
				return;
			}
			while (jsonReader.Read())
			{
				if (jsonReader.TokenType != JsonToken.Comment)
				{
					throw JsonSerializationException.Create(jsonReader, "Additional text found in JSON string after finishing deserializing object.");
				}
			}
		}

		public static string SerializeXmlNode([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] XmlNode node)
		{
			return SerializeXmlNode(node, Formatting.None);
		}

		public static string SerializeXmlNode([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] XmlNode node, Formatting formatting)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		public static string SerializeXmlNode([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] XmlNode node, Formatting formatting, bool omitRootObject)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
			{
				OmitRootObject = omitRootObject
			};
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		public static XmlDocument DeserializeXmlNode(string value)
		{
			return DeserializeXmlNode(value, null);
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
		public static XmlDocument DeserializeXmlNode([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)] string value, string deserializeRootElementName)
		{
			return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute: false);
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
		public static XmlDocument DeserializeXmlNode([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)] string value, string deserializeRootElementName, bool writeArrayAttribute)
		{
			return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
		public static XmlDocument DeserializeXmlNode([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)] string value, string deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
			xmlNodeConverter.DeserializeRootElementName = deserializeRootElementName;
			xmlNodeConverter.WriteArrayAttribute = writeArrayAttribute;
			xmlNodeConverter.EncodeSpecialCharacters = encodeSpecialCharacters;
			return (XmlDocument)DeserializeObject(value, typeof(XmlDocument), xmlNodeConverter);
		}

		public static string SerializeXNode([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] XObject node)
		{
			return SerializeXNode(node, Formatting.None);
		}

		public static string SerializeXNode([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] XObject node, Formatting formatting)
		{
			return SerializeXNode(node, formatting, omitRootObject: false);
		}

		public static string SerializeXNode([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] XObject node, Formatting formatting, bool omitRootObject)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
			{
				OmitRootObject = omitRootObject
			};
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		public static XDocument DeserializeXNode(string value)
		{
			return DeserializeXNode(value, null);
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
		public static XDocument DeserializeXNode([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)] string value, string deserializeRootElementName)
		{
			return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute: false);
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
		public static XDocument DeserializeXNode([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)] string value, string deserializeRootElementName, bool writeArrayAttribute)
		{
			return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
		public static XDocument DeserializeXNode([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)] string value, string deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
			xmlNodeConverter.DeserializeRootElementName = deserializeRootElementName;
			xmlNodeConverter.WriteArrayAttribute = writeArrayAttribute;
			xmlNodeConverter.EncodeSpecialCharacters = encodeSpecialCharacters;
			return (XDocument)DeserializeObject(value, typeof(XDocument), xmlNodeConverter);
		}
	}
	[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
	[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(0)]
	internal abstract class JsonConverter
	{
		public virtual bool CanRead => true;

		public virtual bool CanWrite => true;

		public abstract void WriteJson(JsonWriter writer, [<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] object value, JsonSerializer serializer);

		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		public abstract object ReadJson(JsonReader reader, Type objectType, [<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] object existingValue, JsonSerializer serializer);

		public abstract bool CanConvert(Type objectType);
	}
	[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
	[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(0)]
	internal abstract class JsonConverter<[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] T> : JsonConverter
	{
		public sealed override void WriteJson(JsonWriter writer, [<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] object value, JsonSerializer serializer)
		{
			if (!((value != null) ? (value is T) : ReflectionUtils.IsNullable(typeof(T))))
			{
				throw new JsonSerializationException("Converter cannot write specified value to JSON. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
			}
			WriteJson(writer, (T)value, serializer);
		}

		public abstract void WriteJson(JsonWriter writer, [<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] T value, JsonSerializer serializer);

		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		public sealed override object ReadJson(JsonReader reader, Type objectType, [<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] object existingValue, JsonSerializer serializer)
		{
			bool flag = existingValue == null;
			if (!flag && !(existingValue is T))
			{
				throw new JsonSerializationException("Converter cannot read JSON with the specified existing value. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
			}
			return ReadJson(reader, objectType, flag ? default(T) : ((T)existingValue), !flag, serializer);
		}

		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		public abstract T ReadJson(JsonReader reader, Type objectType, [<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] T existingValue, bool hasExistingValue, JsonSerializer serializer);

		public sealed override bool CanConvert(Type objectType)
		{
			return typeof(T).IsAssignableFrom(objectType);
		}
	}
	[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(0)]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Parameter, AllowMultiple = false)]
	[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
	internal sealed class JsonConverterAttribute : Attribute
	{
		private readonly Type _converterType;

		public Type ConverterType => _converterType;

		[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
		[field: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
		public object[] ConverterParameters
		{
			[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
			get;
		}

		public JsonConverterAttribute(Type converterType)
		{
			if (converterType == null)
			{
				throw new ArgumentNullException("converterType");
			}
			_converterType = converterType;
		}

		public JsonConverterAttribute(Type converterType, params object[] converterParameters)
			: this(converterType)
		{
			ConverterParameters = converterParameters;
		}
	}
	[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 0, 1 })]
	internal class JsonConverterCollection : Collection<JsonConverter>
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
	internal sealed class JsonDictionaryAttribute : JsonContainerAttribute
	{
		public JsonDictionaryAttribute()
		{
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		public JsonDictionaryAttribute(string id)
			: base(id)
		{
		}
	}
	[Serializable]
	[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(0)]
	[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
	internal class JsonException : Exception
	{
		public JsonException()
		{
		}

		public JsonException(string message)
			: base(message)
		{
		}

		public JsonException(string message, [<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] Exception innerException)
			: base(message, innerException)
		{
		}

		public JsonException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}

		internal static JsonException Create(IJsonLineInfo lineInfo, string path, string message)
		{
			message = JsonPosition.FormatMessage(lineInfo, path, message);
			return new JsonException(message);
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal class JsonExtensionDataAttribute : Attribute
	{
		public bool WriteData { get; set; }

		public bool ReadData { get; set; }

		public JsonExtensionDataAttribute()
		{
			WriteData = true;
			ReadData = true;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class JsonIgnoreAttribute : Attribute
	{
	}
	internal abstract class JsonNameTable
	{
		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		public abstract string Get(char[] key, int start, int length);
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, AllowMultiple = false)]
	internal sealed class JsonObjectAttribute : JsonContainerAttribute
	{
		private MemberSerialization _memberSerialization;

		internal MissingMemberHandling? _missingMemberHandling;

		internal Required? _itemRequired;

		internal NullValueHandling? _itemNullValueHandling;

		public MemberSerialization MemberSerialization
		{
			get
			{
				return _memberSerialization;
			}
			set
			{
				_memberSerialization = value;
			}
		}

		public MissingMemberHandling MissingMemberHandling
		{
			get
			{
				return _missingMemberHandling.GetValueOrDefault();
			}
			set
			{
				_missingMemberHandling = value;
			}
		}

		public NullValueHandling ItemNullValueHandling
		{
			get
			{
				return _itemNullValueHandling.GetValueOrDefault();
			}
			set
			{
				_itemNullValueHandling = value;
			}
		}

		public Required ItemRequired
		{
			get
			{
				return _itemRequired.GetValueOrDefault();
			}
			set
			{
				_itemRequired = value;
			}
		}

		public JsonObjectAttribute()
		{
		}

		public JsonObjectAttribute(MemberSerialization memberSerialization)
		{
			MemberSerialization = memberSerialization;
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		public JsonObjectAttribute(string id)
			: base(id)
		{
		}
	}
	internal enum JsonContainerType
	{
		None,
		Object,
		Array,
		Constructor
	}
	[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
	[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(0)]
	internal struct JsonPosition
	{
		private static readonly char[] SpecialCharacters = new char[18]
		{
			'.', ' ', '\'', '/', '"', '[', ']', '(', ')', '\t',
			'\n', '\r', '\f', '\b', '\\', '\u0085', '\u2028', '\u2029'
		};

		internal JsonContainerType Type;

		internal int Position;

		[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)]
		internal string PropertyName;

		internal bool HasIndex;

		public JsonPosition(JsonContainerType type)
		{
			Type = type;
			HasIndex = TypeHasIndex(type);
			Position = -1;
			PropertyName = null;
		}

		internal int CalculateLength()
		{
			switch (Type)
			{
			case JsonContainerType.Object:
				return PropertyName.Length + 5;
			case JsonContainerType.Array:
			case JsonContainerType.Constructor:
				return MathUtils.IntLength((ulong)Position) + 2;
			default:
				throw new ArgumentOutOfRangeException("Type");
			}
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
		internal void WriteTo([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)] StringBuilder sb, ref StringWriter writer, ref char[] buffer)
		{
			switch (Type)
			{
			case JsonContainerType.Object:
			{
				string propertyName = PropertyName;
				if (propertyName.IndexOfAny(SpecialCharacters) != -1)
				{
					sb.Append("['");
					if (writer == null)
					{
						writer = new StringWriter(sb);
					}
					JavaScriptUtils.WriteEscapedJavaScriptString(writer, propertyName, '\'', appendDelimiters: false, JavaScriptUtils.SingleQuoteCharEscapeFlags, StringEscapeHandling.Default, null, ref buffer);
					sb.Append("']");
				}
				else
				{
					if (sb.Length > 0)
					{
						sb.Append('.');
					}
					sb.Append(propertyName);
				}
				break;
			}
			case JsonContainerType.Array:
			case JsonContainerType.Constructor:
				sb.Append('[');
				sb.Append(Position);
				sb.Append(']');
				break;
			}
		}

		internal static bool TypeHasIndex(JsonContainerType type)
		{
			if (type != JsonContainerType.Array)
			{
				return type == JsonContainerType.Constructor;
			}
			return true;
		}

		internal static string BuildPath(List<JsonPosition> positions, JsonPosition? currentPosition)
		{
			int num = 0;
			if (positions != null)
			{
				for (int i = 0; i < positions.Count; i++)
				{
					num += positions[i].CalculateLength();
				}
			}
			if (currentPosition.HasValue)
			{
				num += currentPosition.GetValueOrDefault().CalculateLength();
			}
			StringBuilder stringBuilder = new StringBuilder(num);
			StringWriter writer = null;
			char[] buffer = null;
			if (positions != null)
			{
				foreach (JsonPosition position in positions)
				{
					position.WriteTo(stringBuilder, ref writer, ref buffer);
				}
			}
			currentPosition?.WriteTo(stringBuilder, ref writer, ref buffer);
			return stringBuilder.ToString();
		}

		internal static string FormatMessage([<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(2)] IJsonLineInfo lineInfo, string path, string message)
		{
			if (!message.EndsWith(Environment.NewLine, StringComparison.Ordinal))
			{
				message = message.Trim();
				if (!StringUtils.EndsWith(message, '.'))
				{
					message += ".";
				}
				message += " ";
			}
			message += "Path '{0}'".FormatWith(CultureInfo.InvariantCulture, path);
			if (lineInfo != null && lineInfo.HasLineInfo())
			{
				message += ", line {0}, position {1}".FormatWith(CultureInfo.InvariantCulture, lineInfo.LineNumber, lineInfo.LinePosition);
			}
			message += ".";
			return message;
		}
	}
	[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(0)]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false)]
	[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
	internal sealed class JsonPropertyAttribute : Attribute
	{
		internal NullValueHandling? _nullValueHandling;

		internal DefaultValueHandling? _defaultValueHandling;

		internal ReferenceLoopHandling? _referenceLoopHandling;

		internal ObjectCreationHandling? _objectCreationHandling;

		internal TypeNameHandling? _typeNameHandling;

		internal bool? _isReference;

		internal int? _order;

		internal Required? _required;

		internal bool? _itemIsReference;

		internal ReferenceLoopHandling? _itemReferenceLoopHandling;

		internal TypeNameHandling? _itemTypeNameHandling;

		public Type ItemConverterType { get; set; }

		[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
		[field: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
		public object[] ItemConverterParameters
		{
			[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
			get;
			[param: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
			set;
		}

		public Type NamingStrategyType { get; set; }

		[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
		[field: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
		public object[] NamingStrategyParameters
		{
			[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
			get;
			[param: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 2, 1 })]
			set;
		}

		public NullValueHandling NullValueHandling
		{
			get
			{
				return _nullValueHandling.GetValueOrDefault();
			}
			set
			{
				_nullValueHandling = value;
			}
		}

		public DefaultValueHandling DefaultValueHandling
		{
			get
			{
				return _defaultValueHandling.GetValueOrDefault();
			}
			set
			{
				_defaultValueHandling = value;
			}
		}

		public ReferenceLoopHandling ReferenceLoopHandling
		{
			get
			{
				return _referenceLoopHandling.GetValueOrDefault();
			}
			set
			{
				_referenceLoopHandling = value;
			}
		}

		public ObjectCreationHandling ObjectCreationHandling
		{
			get
			{
				return _objectCreationHandling.GetValueOrDefault();
			}
			set
			{
				_objectCreationHandling = value;
			}
		}

		public TypeNameHandling TypeNameHandling
		{
			get
			{
				return _typeNameHandling.GetValueOrDefault();
			}
			set
			{
				_typeNameHandling = value;
			}
		}

		public bool IsReference
		{
			get
			{
				return _isReference.GetValueOrDefault();
			}
			set
			{
				_isReference = value;
			}
		}

		public int Order
		{
			get
			{
				return _order.GetValueOrDefault();
			}
			set
			{
				_order = value;
			}
		}

		public Required Required
		{
			get
			{
				return _required.GetValueOrDefault();
			}
			set
			{
				_required = value;
			}
		}

		public string PropertyName { get; set; }

		public ReferenceLoopHandling ItemReferenceLoopHandling
		{
			get
			{
				return _itemReferenceLoopHandling.GetValueOrDefault();
			}
			set
			{
				_itemReferenceLoopHandling = value;
			}
		}

		public TypeNameHandling ItemTypeNameHandling
		{
			get
			{
				return _itemTypeNameHandling.GetValueOrDefault();
			}
			set
			{
				_itemTypeNameHandling = value;
			}
		}

		public bool ItemIsReference
		{
			get
			{
				return _itemIsReference.GetValueOrDefault();
			}
			set
			{
				_itemIsReference = value;
			}
		}

		public JsonPropertyAttribute()
		{
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		public JsonPropertyAttribute(string propertyName)
		{
			PropertyName = propertyName;
		}
	}
	[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(2)]
	[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(0)]
	internal abstract class JsonReader : IDisposable
	{
		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(0)]
		protected internal enum State
		{
			Start,
			Complete,
			Property,
			ObjectStart,
			Object,
			ArrayStart,
			Array,
			Closed,
			PostValue,
			ConstructorStart,
			Constructor,
			Error,
			Finished
		}

		private JsonToken _tokenType;

		private object _value;

		internal char _quoteChar;

		internal State _currentState;

		private JsonPosition _currentPosition;

		private CultureInfo _culture;

		private DateTimeZoneHandling _dateTimeZoneHandling;

		private int? _maxDepth;

		private bool _hasExceededMaxDepth;

		internal DateParseHandling _dateParseHandling;

		internal FloatParseHandling _floatParseHandling;

		private string _dateFormatString;

		private List<JsonPosition> _stack;

		protected State CurrentState => _currentState;

		public bool CloseInput { get; set; }

		public bool SupportMultipleContent { get; set; }

		public virtual char QuoteChar
		{
			get
			{
				return _quoteChar;
			}
			protected internal set
			{
				_quoteChar = value;
			}
		}

		public DateTimeZoneHandling DateTimeZoneHandling
		{
			get
			{
				return _dateTimeZoneHandling;
			}
			set
			{
				if (value < DateTimeZoneHandling.Local || value > DateTimeZoneHandling.RoundtripKind)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_dateTimeZoneHandling = value;
			}
		}

		public DateParseHandling DateParseHandling
		{
			get
			{
				return _dateParseHandling;
			}
			set
			{
				if (value < DateParseHandling.None || value > DateParseHandling.DateTimeOffset)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_dateParseHandling = value;
			}
		}

		public FloatParseHandling FloatParseHandling
		{
			get
			{
				return _floatParseHandling;
			}
			set
			{
				if (value < FloatParseHandling.Double || value > FloatParseHandling.Decimal)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_floatParseHandling = value;
			}
		}

		public string DateFormatString
		{
			get
			{
				return _dateFormatString;
			}
			set
			{
				_dateFormatString = value;
			}
		}

		public int? MaxDepth
		{
			get
			{
				return _maxDepth;
			}
			set
			{
				if (value <= 0)
				{
					throw new ArgumentException("Value must be positive.", "value");
				}
				_maxDepth = value;
			}
		}

		public virtual JsonToken TokenType => _tokenType;

		public virtual object Value => _value;

		public virtual Type ValueType => _value?.GetType();

		public virtual int Depth
		{
			get
			{
				int num = _stack?.Count ?? 0;
				if (JsonTokenUtils.IsStartToken(TokenType) || _currentPosition.Type == JsonContainerType.None)
				{
					return num;
				}
				return num + 1;
			}
		}

		[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)]
		public virtual string Path
		{
			[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
			get
			{
				if (_currentPosition.Type == JsonContainerType.None)
				{
					return string.Empty;
				}
				JsonPosition? currentPosition = ((_currentState != State.ArrayStart && _currentState != State.ConstructorStart && _currentState != State.ObjectStart) ? new JsonPosition?(_currentPosition) : null);
				return JsonPosition.BuildPath(_stack, currentPosition);
			}
		}

		[<94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(1)]
		public CultureInfo Culture
		{
			[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
			get
			{
				return _culture ?? CultureInfo.InvariantCulture;
			}
			[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
			set
			{
				_culture = value;
			}
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		public virtual Task<bool> ReadAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<bool>() ?? Read().ToAsync();
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		public async Task SkipAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (TokenType == JsonToken.PropertyName)
			{
				await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			if (JsonTokenUtils.IsStartToken(TokenType))
			{
				int depth = Depth;
				while (await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false) && depth < Depth)
				{
				}
			}
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		internal async Task ReaderReadAndAssertAsync(CancellationToken cancellationToken)
		{
			if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
			{
				throw CreateUnexpectedEndException();
			}
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		public virtual Task<bool?> ReadAsBooleanAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<bool?>() ?? Task.FromResult(ReadAsBoolean());
		}

		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 1, 2 })]
		public virtual Task<byte[]> ReadAsBytesAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<byte[]>() ?? Task.FromResult(ReadAsBytes());
		}

		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 1, 2 })]
		internal async Task<byte[]> ReadArrayIntoByteArrayAsync(CancellationToken cancellationToken)
		{
			List<byte> buffer = new List<byte>();
			do
			{
				if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
				{
					SetToken(JsonToken.None);
				}
			}
			while (!ReadArrayElementIntoByteArrayReportDone(buffer));
			byte[] array = buffer.ToArray();
			SetToken(JsonToken.Bytes, array, updateIndex: false);
			return array;
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		public virtual Task<DateTime?> ReadAsDateTimeAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<DateTime?>() ?? Task.FromResult(ReadAsDateTime());
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		public virtual Task<DateTimeOffset?> ReadAsDateTimeOffsetAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<DateTimeOffset?>() ?? Task.FromResult(ReadAsDateTimeOffset());
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		public virtual Task<decimal?> ReadAsDecimalAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<decimal?>() ?? Task.FromResult(ReadAsDecimal());
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		public virtual Task<double?> ReadAsDoubleAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return Task.FromResult(ReadAsDouble());
		}

		[<54df5b1c-9970-400c-9dde-f1e30852f343>NullableContext(1)]
		public virtual Task<int?> ReadAsInt32Async(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<int?>() ?? Task.FromResult(ReadAsInt32());
		}

		[return: <94d2f417-f14b-4d6a-990c-aabc0b494c9f>Nullable(new byte[] { 1, 2 })]
		public virtual Task<string> ReadAsStringAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequested