using System;
using System.Buffers;
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.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.AccessControl;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Security.Principal;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Linq;
using BepInEx;
using FxResources.System.Buffers;
using HarmonyLib;
using LiteDB.Engine;
using LiteDB.Utils;
using LiteDB.Utils.Extensions;
using Microsoft.CodeAnalysis;
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 UnityEngine;
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.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[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: <3dbc13d8-b9f3-46e8-a269-269a6f489ccb>RefSafetyRules(11)]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<857753a0-4732-4257-a8b7-3aeea7a54362>Embedded]
	internal sealed class <857753a0-4732-4257-a8b7-3aeea7a54362>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<857753a0-4732-4257-a8b7-3aeea7a54362>Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class <3dbc13d8-b9f3-46e8-a269-269a6f489ccb>RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public <3dbc13d8-b9f3-46e8-a269-269a6f489ccb>RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[HarmonyPatch(typeof(Character), "SetLevel")]
public static class CharacterSetLevelPatch
{
	public static void Postfix(Character __instance, int level)
	{
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)__instance == (Object)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 (!((Object)(object)__instance == (Object)null) && !__instance.IsTamed() && !__instance.IsPlayer())
			{
				Debug.Log((object)$"[TerritoryStars] {((Object)__instance).name} set to level {level} at {((Component)__instance).transform.position}");
				EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = $"[TerritoryStars] {((Object)__instance).name} set to level {level} at {((Component)__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()
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			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;
					}
					Vector3 position = ((Component)__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 {((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 ((Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsValid())
					{
						EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = "[TerritoryStars] Skipping SetLevel — m_nview is null or invalid for " + ((Object)__instance).name + "." });
						return false;
					}
					int level = __instance.GetLevel();
					if ((Object)(object)__instance.m_nview != (Object)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 {((Object)__instance).name} at {((Component)__instance).transform.position} in zone '{territoryAt.Name}'." });
							}
							else
							{
								EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = "[TerritoryStars] ⚠\ufe0f ZDO is null for " + ((Object)__instance).name + ", could not set creatureLevel." });
							}
						}
						else
						{
							EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = "[TerritoryStars] ⚠\ufe0f m_nview is not valid for " + ((Object)__instance).name + ", skipping creatureLevel set." });
						}
					}
					else
					{
						EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = "[TerritoryStars] ⚠\ufe0f m_nview is null for " + ((Object)__instance).name + ", skipping creatureLevel set." });
					}
					__instance.SetLevel(territoryAt.AddStars);
					EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = $"[TerritoryStars] Boosted {((Object)__instance).name} from level {level} → {territoryAt.AddStars} in territory '{territoryAt.Name}'." });
					string value = $"[TerritoryStars] Start triggered for: {__instance.GetHoverName()} at {((Component)__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 (!((Object)(object)__instance.m_nview == (Object)null) && __instance.m_nview.IsValid() && !((Object)(object)__instance == (Object)null) && !__instance.IsTamed())
		{
			((MonoBehaviour)__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
		};
	}
}
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 HelreidManagers
{
	[BepInPlugin("helreid.bepinex.plugins.einherjarslegacy", "EinherjarsLegacyClient", "1.0.0")]
	public class HelreidManager : BaseUnityPlugin
	{
		public const string ModName = "EinherjarsLegacyClient";

		public const string ModVersion = "1.0.0";

		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 = "";

		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();
		}

		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, 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 Vector3 Center => new 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";

		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)
					{
						Debug.LogError((object)$"[TerritoryStars] ❌ Failed to fetch territories: {val.StatusCode}");
						return;
					}
					Territories = JsonConvert.DeserializeObject<List<MarketplaceTerritory>>(await val.Content.ReadAsStringAsync()) ?? new List<MarketplaceTerritory>();
					Debug.Log((object)$"[TerritoryStars] ✅ Loaded {Territories.Count} territories.");
				}
				finally
				{
					((IDisposable)client)?.Dispose();
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[TerritoryStars] ❌ Exception while loading territories: {arg}");
			}
		}

		public static MarketplaceTerritory GetTerritoryAt(Vector3 position)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val2 = default(Vector2);
			foreach (MarketplaceTerritory territory in Territories)
			{
				Vector2 val = new Vector2(position.x, position.z);
				((Vector2)(ref val2))..ctor(territory.Center.x, territory.Center.z);
				if (Vector2.Distance(val, val2) <= territory.RadiusValue && territory.AddStars > 0)
				{
					return territory;
				}
			}
			return null;
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<d8974deb-8f90-430c-ad4c-9c794da5306a>Embedded]
	internal sealed class <d8974deb-8f90-430c-ad4c-9c794da5306a>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[<d8974deb-8f90-430c-ad4c-9c794da5306a>Embedded]
	[CompilerGenerated]
	internal sealed class <f5b12311-c7d5-4510-92ca-9875f1474a4e>IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[<d8974deb-8f90-430c-ad4c-9c794da5306a>Embedded]
	internal sealed class <bfb1d501-6547-4ce1-bd26-54ea66b4a195>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <bfb1d501-6547-4ce1-bd26-54ea66b4a195>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <bfb1d501-6547-4ce1-bd26-54ea66b4a195>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[<d8974deb-8f90-430c-ad4c-9c794da5306a>Embedded]
	internal sealed class <7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <7f8b39b3-9436-4fea-b300-6209451c3f7e>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
	}
	[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(0)]
	[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
	internal class DefaultJsonNameTable : JsonNameTable
	{
		[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>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
	}
	[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
	internal interface IArrayPool<[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] T>
	{
		T[] Rent(int minimumLength);

		void Return([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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;
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>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)]
	[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
	[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(0)]
	internal abstract class JsonContainerAttribute : Attribute
	{
		internal bool? _isReference;

		internal bool? _itemIsReference;

		internal ReferenceLoopHandling? _itemReferenceLoopHandling;

		internal TypeNameHandling? _itemTypeNameHandling;

		private Type _namingStrategyType;

		[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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; }

		[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
		[field: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
		public object[] ItemConverterParameters
		{
			[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
			get;
			[param: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
			set;
		}

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

		[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
		public object[] NamingStrategyParameters
		{
			[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
			get
			{
				return _namingStrategyParameters;
			}
			[param: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>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()
		{
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		protected JsonContainerAttribute(string id)
		{
			Id = id;
		}
	}
	[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
	[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(0)]
	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";

		[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
		[field: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
		public static Func<JsonSerializerSettings> DefaultSettings
		{
			[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
			get;
			[param: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>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([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] string value)
		{
			return ToString(value, '"');
		}

		public static string ToString([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] string value, char delimiter)
		{
			return ToString(value, delimiter, StringEscapeHandling.Default);
		}

		public static string ToString([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] object value)
		{
			return SerializeObject(value, (Type)null, (JsonSerializerSettings)null);
		}

		[DebuggerStepThrough]
		public static string SerializeObject([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] object value, Formatting formatting)
		{
			return SerializeObject(value, formatting, (JsonSerializerSettings)null);
		}

		[DebuggerStepThrough]
		public static string SerializeObject([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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);
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
		[DebuggerStepThrough]
		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(1)]
		public static string SerializeObject(object value, JsonSerializerSettings settings)
		{
			return SerializeObject(value, null, settings);
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
		[DebuggerStepThrough]
		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(1)]
		public static string SerializeObject(object value, Type type, JsonSerializerSettings settings)
		{
			JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
			return SerializeObjectInternal(value, type, jsonSerializer);
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
		[DebuggerStepThrough]
		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(1)]
		public static string SerializeObject(object value, Formatting formatting, JsonSerializerSettings settings)
		{
			return SerializeObject(value, null, formatting, settings);
		}

		[DebuggerStepThrough]
		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>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([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] object value, [<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)]
		public static object DeserializeObject(string value)
		{
			return DeserializeObject(value, (Type)null, (JsonSerializerSettings)null);
		}

		[DebuggerStepThrough]
		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)]
		public static object DeserializeObject(string value, JsonSerializerSettings settings)
		{
			return DeserializeObject(value, null, settings);
		}

		[DebuggerStepThrough]
		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)]
		public static object DeserializeObject(string value, Type type)
		{
			return DeserializeObject(value, type, (JsonSerializerSettings)null);
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
		[DebuggerStepThrough]
		public static T DeserializeObject<T>([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(1)] string value)
		{
			return JsonConvert.DeserializeObject<T>(value, (JsonSerializerSettings)null);
		}

		[DebuggerStepThrough]
		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)]
		public static T DeserializeAnonymousType<[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] T>(string value, T anonymousTypeObject)
		{
			return DeserializeObject<T>(value);
		}

		[DebuggerStepThrough]
		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)]
		public static T DeserializeAnonymousType<[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] T>(string value, T anonymousTypeObject, JsonSerializerSettings settings)
		{
			return DeserializeObject<T>(value, settings);
		}

		[DebuggerStepThrough]
		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)]
		public static T DeserializeObject<[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] T>(string value, params JsonConverter[] converters)
		{
			return (T)DeserializeObject(value, typeof(T), converters);
		}

		[DebuggerStepThrough]
		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
		public static T DeserializeObject<T>([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(1)] string value, JsonSerializerSettings settings)
		{
			return (T)DeserializeObject(value, typeof(T), settings);
		}

		[DebuggerStepThrough]
		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>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);
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
		public static object DeserializeObject([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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, [<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] XmlNode node)
		{
			return SerializeXmlNode(node, Formatting.None);
		}

		public static string SerializeXmlNode([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] XmlNode node, Formatting formatting)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		public static string SerializeXmlNode([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] XmlNode node, Formatting formatting, bool omitRootObject)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
			{
				OmitRootObject = omitRootObject
			};
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)]
		public static XmlDocument DeserializeXmlNode(string value)
		{
			return DeserializeXmlNode(value, null);
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
		public static XmlDocument DeserializeXmlNode([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(1)] string value, string deserializeRootElementName)
		{
			return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute: false);
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
		public static XmlDocument DeserializeXmlNode([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(1)] string value, string deserializeRootElementName, bool writeArrayAttribute)
		{
			return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
		public static XmlDocument DeserializeXmlNode([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] XObject node)
		{
			return SerializeXNode(node, Formatting.None);
		}

		public static string SerializeXNode([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] XObject node, Formatting formatting)
		{
			return SerializeXNode(node, formatting, omitRootObject: false);
		}

		public static string SerializeXNode([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] XObject node, Formatting formatting, bool omitRootObject)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
			{
				OmitRootObject = omitRootObject
			};
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)]
		public static XDocument DeserializeXNode(string value)
		{
			return DeserializeXNode(value, null);
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
		public static XDocument DeserializeXNode([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(1)] string value, string deserializeRootElementName)
		{
			return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute: false);
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
		public static XDocument DeserializeXNode([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(1)] string value, string deserializeRootElementName, bool writeArrayAttribute)
		{
			return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
		public static XDocument DeserializeXNode([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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);
		}
	}
	[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(0)]
	[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
	internal abstract class JsonConverter
	{
		public virtual bool CanRead => true;

		public virtual bool CanWrite => true;

		public abstract void WriteJson(JsonWriter writer, [<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] object value, JsonSerializer serializer);

		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)]
		public abstract object ReadJson(JsonReader reader, Type objectType, [<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] object existingValue, JsonSerializer serializer);

		public abstract bool CanConvert(Type objectType);
	}
	[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
	[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(0)]
	internal abstract class JsonConverter<[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] T> : JsonConverter
	{
		public sealed override void WriteJson(JsonWriter writer, [<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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, [<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] T value, JsonSerializer serializer);

		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)]
		public sealed override object ReadJson(JsonReader reader, Type objectType, [<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)]
		public abstract T ReadJson(JsonReader reader, Type objectType, [<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(2)] T existingValue, bool hasExistingValue, JsonSerializer serializer);

		public sealed override bool CanConvert(Type objectType)
		{
			return typeof(T).IsAssignableFrom(objectType);
		}
	}
	[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
	[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(0)]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Parameter, AllowMultiple = false)]
	internal sealed class JsonConverterAttribute : Attribute
	{
		private readonly Type _converterType;

		public Type ConverterType => _converterType;

		[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
		[field: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
		public object[] ConverterParameters
		{
			[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>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;
		}
	}
	[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 0, 1 })]
	internal class JsonConverterCollection : Collection<JsonConverter>
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
	internal sealed class JsonDictionaryAttribute : JsonContainerAttribute
	{
		public JsonDictionaryAttribute()
		{
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		public JsonDictionaryAttribute(string id)
			: base(id)
		{
		}
	}
	[Serializable]
	[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(0)]
	[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
	internal class JsonException : Exception
	{
		public JsonException()
		{
		}

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

		public JsonException(string message, [<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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
	{
		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>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;
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		public JsonObjectAttribute(string id)
			: base(id)
		{
		}
	}
	internal enum JsonContainerType
	{
		None,
		Object,
		Array,
		Constructor
	}
	[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
	[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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;

		[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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");
			}
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
		internal void WriteTo([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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([<bfb1d501-6547-4ce1-bd26-54ea66b4a195>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;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false)]
	[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(0)]
	[<7f8b39b3-9436-4fea-b300-6209451c3f7e>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; }

		[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
		[field: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
		public object[] ItemConverterParameters
		{
			[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
			get;
			[param: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
			set;
		}

		public Type NamingStrategyType { get; set; }

		[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
		[field: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
		public object[] NamingStrategyParameters
		{
			[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 2, 1 })]
			get;
			[param: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>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()
		{
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		public JsonPropertyAttribute(string propertyName)
		{
			PropertyName = propertyName;
		}
	}
	[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(2)]
	[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(0)]
	internal abstract class JsonReader : IDisposable
	{
		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>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;
			}
		}

		[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(1)]
		public virtual string Path
		{
			[<7f8b39b3-9436-4fea-b300-6209451c3f7e>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);
			}
		}

		[<bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(1)]
		public CultureInfo Culture
		{
			[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
			get
			{
				return _culture ?? CultureInfo.InvariantCulture;
			}
			[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
			set
			{
				_culture = value;
			}
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		public virtual Task<bool> ReadAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<bool>() ?? Read().ToAsync();
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>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)
				{
				}
			}
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		internal async Task ReaderReadAndAssertAsync(CancellationToken cancellationToken)
		{
			if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
			{
				throw CreateUnexpectedEndException();
			}
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		public virtual Task<bool?> ReadAsBooleanAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<bool?>() ?? Task.FromResult(ReadAsBoolean());
		}

		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 1, 2 })]
		public virtual Task<byte[]> ReadAsBytesAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<byte[]>() ?? Task.FromResult(ReadAsBytes());
		}

		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>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;
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		public virtual Task<DateTime?> ReadAsDateTimeAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<DateTime?>() ?? Task.FromResult(ReadAsDateTime());
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		public virtual Task<DateTimeOffset?> ReadAsDateTimeOffsetAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<DateTimeOffset?>() ?? Task.FromResult(ReadAsDateTimeOffset());
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		public virtual Task<decimal?> ReadAsDecimalAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<decimal?>() ?? Task.FromResult(ReadAsDecimal());
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		public virtual Task<double?> ReadAsDoubleAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return Task.FromResult(ReadAsDouble());
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		public virtual Task<int?> ReadAsInt32Async(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<int?>() ?? Task.FromResult(ReadAsInt32());
		}

		[return: <bfb1d501-6547-4ce1-bd26-54ea66b4a195>Nullable(new byte[] { 1, 2 })]
		public virtual Task<string> ReadAsStringAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<string>() ?? Task.FromResult(ReadAsString());
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		internal async Task<bool> ReadAndMoveToContentAsync(CancellationToken cancellationToken)
		{
			bool flag = await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			if (flag)
			{
				flag = await MoveToContentAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			return flag;
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		internal Task<bool> MoveToContentAsync(CancellationToken cancellationToken)
		{
			JsonToken tokenType = TokenType;
			if (tokenType == JsonToken.None || tokenType == JsonToken.Comment)
			{
				return MoveToContentFromNonContentAsync(cancellationToken);
			}
			return AsyncUtils.True;
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		private async Task<bool> MoveToContentFromNonContentAsync(CancellationToken cancellationToken)
		{
			JsonToken tokenType;
			do
			{
				if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
				{
					return false;
				}
				tokenType = TokenType;
			}
			while (tokenType == JsonToken.None || tokenType == JsonToken.Comment);
			return true;
		}

		internal JsonPosition GetPosition(int depth)
		{
			if (_stack != null && depth < _stack.Count)
			{
				return _stack[depth];
			}
			return _currentPosition;
		}

		protected JsonReader()
		{
			_currentState = State.Start;
			_dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
			_dateParseHandling = DateParseHandling.DateTime;
			_floatParseHandling = FloatParseHandling.Double;
			_maxDepth = 64;
			CloseInput = true;
		}

		private void Push(JsonContainerType value)
		{
			UpdateScopeWithFinishedValue();
			if (_currentPosition.Type == JsonContainerType.None)
			{
				_currentPosition = new JsonPosition(value);
				return;
			}
			if (_stack == null)
			{
				_stack = new List<JsonPosition>();
			}
			_stack.Add(_currentPosition);
			_currentPosition = new JsonPosition(value);
			if (!_maxDepth.HasValue || !(Depth + 1 > _maxDepth) || _hasExceededMaxDepth)
			{
				return;
			}
			_hasExceededMaxDepth = true;
			throw JsonReaderException.Create(this, "The reader's MaxDepth of {0} has been exceeded.".FormatWith(CultureInfo.InvariantCulture, _maxDepth));
		}

		private JsonContainerType Pop()
		{
			JsonPosition currentPosition;
			if (_stack != null && _stack.Count > 0)
			{
				currentPosition = _currentPosition;
				_currentPosition = _stack[_stack.Count - 1];
				_stack.RemoveAt(_stack.Count - 1);
			}
			else
			{
				currentPosition = _currentPosition;
				_currentPosition = default(JsonPosition);
			}
			if (_maxDepth.HasValue && Depth <= _maxDepth)
			{
				_hasExceededMaxDepth = false;
			}
			return currentPosition.Type;
		}

		private JsonContainerType Peek()
		{
			return _currentPosition.Type;
		}

		public abstract bool Read();

		public virtual int? ReadAsInt32()
		{
			JsonToken contentToken = GetContentToken();
			switch (contentToken)
			{
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.Integer:
			case JsonToken.Float:
			{
				object value = Value;
				if (value is int)
				{
					return (int)value;
				}
				int num;
				if (value is BigInteger bigInteger)
				{
					num = (int)bigInteger;
				}
				else
				{
					try
					{
						num = Convert.ToInt32(value, CultureInfo.InvariantCulture);
					}
					catch (Exception ex)
					{
						throw JsonReaderException.Create(this, "Could not convert to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, value), ex);
					}
				}
				SetToken(JsonToken.Integer, num, updateIndex: false);
				return num;
			}
			case JsonToken.String:
			{
				string s = (string)Value;
				return ReadInt32String(s);
			}
			default:
				throw JsonReaderException.Create(this, "Error reading integer. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
			}
		}

		internal int? ReadInt32String(string s)
		{
			if (StringUtils.IsNullOrEmpty(s))
			{
				SetToken(JsonToken.Null, null, updateIndex: false);
				return null;
			}
			if (int.TryParse(s, NumberStyles.Integer, Culture, out var result))
			{
				SetToken(JsonToken.Integer, result, updateIndex: false);
				return result;
			}
			SetToken(JsonToken.String, s, updateIndex: false);
			throw JsonReaderException.Create(this, "Could not convert string to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
		}

		public virtual string ReadAsString()
		{
			JsonToken contentToken = GetContentToken();
			switch (contentToken)
			{
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.String:
				return (string)Value;
			default:
				if (JsonTokenUtils.IsPrimitiveToken(contentToken))
				{
					object value = Value;
					if (value != null)
					{
						string text = ((!(value is IFormattable formattable)) ? ((value is Uri uri) ? uri.OriginalString : value.ToString()) : formattable.ToString(null, Culture));
						SetToken(JsonToken.String, text, updateIndex: false);
						return text;
					}
				}
				throw JsonReaderException.Create(this, "Error reading string. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
			}
		}

		public virtual byte[] ReadAsBytes()
		{
			JsonToken contentToken = GetContentToken();
			switch (contentToken)
			{
			case JsonToken.StartObject:
			{
				ReadIntoWrappedTypeObject();
				byte[] array2 = ReadAsBytes();
				ReaderReadAndAssert();
				if (TokenType != JsonToken.EndObject)
				{
					throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
				}
				SetToken(JsonToken.Bytes, array2, updateIndex: false);
				return array2;
			}
			case JsonToken.String:
			{
				string text = (string)Value;
				Guid g;
				byte[] array3 = ((text.Length == 0) ? CollectionUtils.ArrayEmpty<byte>() : ((!ConvertUtils.TryConvertGuid(text, out g)) ? Convert.FromBase64String(text) : g.ToByteArray()));
				SetToken(JsonToken.Bytes, array3, updateIndex: false);
				return array3;
			}
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.Bytes:
				if (Value is Guid guid)
				{
					byte[] array = guid.ToByteArray();
					SetToken(JsonToken.Bytes, array, updateIndex: false);
					return array;
				}
				return (byte[])Value;
			case JsonToken.StartArray:
				return ReadArrayIntoByteArray();
			default:
				throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
			}
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		internal byte[] ReadArrayIntoByteArray()
		{
			List<byte> list = new List<byte>();
			do
			{
				if (!Read())
				{
					SetToken(JsonToken.None);
				}
			}
			while (!ReadArrayElementIntoByteArrayReportDone(list));
			byte[] array = list.ToArray();
			SetToken(JsonToken.Bytes, array, updateIndex: false);
			return array;
		}

		[<7f8b39b3-9436-4fea-b300-6209451c3f7e>NullableContext(1)]
		private bool ReadArrayElementIntoByteArrayReportDone(List<byte> buffer)
		{
			switch (TokenType)
			{
			case JsonToken.None:
				throw JsonReaderException.Create(this, "Unexpected end when reading bytes.");
			case JsonToken.Integer:
				buffer.Add(Convert.ToByte(Value, CultureInfo.InvariantCulture));
				return false;
			case JsonToken.EndArray:
				return true;
			case JsonToken.Comment:
				return false;
			default:
				throw JsonReaderException.Create(this, "Unexpected token when reading bytes: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
			}
		}

		public virtual double? ReadAsDouble()
		{
			JsonToken contentToken = GetContentToken();
			switch (contentToken)
			{
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.Integer:
			case JsonToken.Float:
			{
				object value = Value;
				if (value is double)
				{
					return (double)value;
				}
				double num = ((!(value is BigInteger bigInteger)) ? Convert.ToDouble(value, CultureInfo.InvariantCulture) : ((double)bigInteger));
				SetToken(JsonToken.Float, num, updateIndex: false);
				return num;
			}
			case JsonToken.String:
				return ReadDoubleString((string)Value);
			default:
				throw JsonReaderException.Create(this, "Error reading double. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
			}
		}

		internal double? ReadDoubleString(string s)
		{
			if (StringUtils.IsNullOrEmpty(s))
			{
				SetToken(JsonToken.Null, null, updateIndex: false);
				return null;
			}
			if (double.TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, Culture, out var result))
			{
				SetToken(JsonToken.Float, result, updateIndex: false);
				return result;
			}
			SetToken(JsonToken.String, s, updateIndex: false);
			throw JsonReaderException.Create(this, "Could not convert string to double: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
		}

		public virtual bool? ReadAsBoolean()
		{
			JsonToken contentToken = GetContentToken();
			switch (contentToken)
			{
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.Integer:
			case JsonToken.Float:
			{
				bool flag = ((!(Value is BigInteger bigInteger)) ? Convert.ToBoolean(Value, CultureInfo.InvariantCulture) : (bigInteger != 0L));
				SetToken(JsonToken.Boolean, flag, updateIndex: false);
				return flag;
			}
			case JsonToken.String:
				return ReadBooleanString((string)Value);
			case JsonToken.Boolean:
				return (bool)Value;
			default:
				throw JsonReaderException.Create(this, "Error reading boolean. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
			}
		}

		internal bool? ReadBooleanString(string s)
		{
			if (StringUtils.IsNullOrEmpty(s))
			{
				SetToken(JsonToken.Null, null, updateIndex: false);
				return null;
			}
			if (bool.TryParse(s, out var result))
			{
				SetToken(JsonToken.Boolean, result, updateIndex: false);
				return result;
			}
			SetToken(JsonToken.String, s, updateIndex: false);
			throw JsonReaderException.Create(this, "Could not convert string to boolean: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
		}

		public virtual decimal? ReadAsDecimal()
		{
			JsonToken contentToken = GetContentToken();
			switch (contentToken)
			{
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.Integer:
			case JsonToken.Float:
			{
				object value = Value;
				if (value is decimal)
				{
					return (decimal)value;
				}
				decimal num;
				if (value is BigInteger bigInteger)
				{
					num = (decimal)bigInteger;
				}
				else
				{
					try
					{
						num = Convert.ToDecimal(value, CultureInfo.InvariantCulture);
					}
					catch (Exception ex)
					{
						throw JsonReaderException.Create(this, "Could not convert to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, value), ex);
					}
				}
				SetToken(JsonToken.Float, num, updateIndex: false);
				return num;
			}
			case JsonToken.String:
				return ReadDecimalString((string)Value);
			default:
				throw JsonReaderException.Create(this, "Error reading decimal. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
			}
		}

		internal decimal? ReadDecimalString(string s)
		{
			if (StringUtils.IsNullOrEmpty(s))
			{
				SetToken(JsonToken.Null, null, updateIndex: false);
				return null;
			}
			if (decimal.TryParse(s, NumberStyles.Number, Culture, out var result))
			{
				SetToken(JsonToken.Float, result, updateIndex: false);
				return result;
			}
			if (ConvertUtils.DecimalTryParse(s.ToCharArray(), 0, s.Length, out result) == ParseResult.Success)
			{
				SetToken(JsonToken.Float, result, updateIndex: false);
				return result;
			}
			SetToken(JsonToken.String, s, updateIndex: false);
			throw JsonReaderException.Create(this, "Could not convert string to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
		}

		public virtual DateTime? ReadAsDateTime()
		{
			switch (GetContentToken())
			{
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.Date:
				if (Value is DateTimeOffset dateTimeOffset)
				{
					SetToken(JsonToken.Date, dateTimeOffset.DateTime, updateIndex: false);
				}
				return (DateTime)Value;
			case JsonToken.String:
				return ReadDateTimeString((string)Value);
			default:
				throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
			}
		}

		internal DateTime? ReadDateTimeString(string s)
		{
			if (StringUtils.IsNullOrEmpty(s))
			{
				SetToken(JsonToken.Null, null, updateIndex: false);
				return null;
			}
			if (DateTimeUtils.TryParseDateTime(s, DateTimeZoneHandling, _dateFormatString, Culture, out var dt))
			{
				dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
				SetToken(JsonToken.Date, dt, updateIndex: false);
				return dt;
			}
			if (DateTime.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt))
			{
				dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
				SetToken(JsonToken.Date, dt, updateIndex: false);
				return dt;
			}
			throw JsonReaderException.Create(this, "Could not convert string to DateTime: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
		}

		public virtual DateTimeOffset? ReadAsDateTimeOffset()
		{
			JsonToken contentToken = GetContentToken();
			switch (contentToken)
			{
			case JsonToken.None:
			case JsonToken.Null:
			case JsonToken.EndArray:
				return null;
			case JsonToken.Date:
				if (Value is DateTime dateTime)
				{
					SetToken(JsonToken.Date, new DateTimeOffset(dateTime), updateIndex: false);
				}
				return (DateTimeOffset)Value;
			case JsonToken.String:
			{
				string s = (string)Value;
				return ReadDate