#define UNITY_ASSERTIONS
using System;
using System.CodeDom.Compiler;
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.Net.NetworkInformation;
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.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Linq;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using FxResources.System.Buffers;
using HarmonyLib;
using HelreidManagers.Helreid;
using JetBrains.Annotations;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Extensions;
using Jotunn.GUI;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using Microsoft.Win32.SafeHandles;
using Mono.Cecil.Cil;
using MonoMod.Cil;
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 SimpleJson;
using SimpleJson.Reflection;
using SoftReferenceableAssets;
using Splatform;
using TMPro;
using TerritoryStars;
using Unity.Baselib.LowLevel;
using Unity.Burst;
using Unity.Burst.LowLevel;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Content;
using Unity.IL2CPP.CompilerServices;
using Unity.Jobs;
using Unity.Jobs.LowLevel.Unsafe;
using Unity.Profiling;
using Unity.Profiling.LowLevel;
using Unity.Profiling.LowLevel.Unsafe;
using UnityEngine;
using UnityEngine.Assertions;
using UnityEngine.Assertions.Comparers;
using UnityEngine.Audio;
using UnityEngine.Bindings;
using UnityEngine.Diagnostics;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Experimental.Rendering;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.DualShock;
using UnityEngine.InputSystem.Layouts;
using UnityEngine.InputSystem.LowLevel;
using UnityEngine.InputSystem.Switch;
using UnityEngine.InputSystem.UI;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.InputSystem.XInput;
using UnityEngine.Internal;
using UnityEngine.Networking.PlayerConnection;
using UnityEngine.Playables;
using UnityEngine.Pool;
using UnityEngine.Profiling;
using UnityEngine.Rendering;
using UnityEngine.Rendering.RendererUtils;
using UnityEngine.SceneManagement;
using UnityEngine.Scripting;
using UnityEngine.Scripting.APIUpdating;
using UnityEngine.Serialization;
using UnityEngine.Sprites;
using UnityEngine.Tilemaps;
using UnityEngine.U2D;
using UnityEngine.UI;
using UnityEngine.UI.Collections;
using UnityEngine.UI.CoroutineTween;
using UnityEngine.UIElements;
using UnityEngineInternal;
using Valheim.SettingsGui;
using Viper.Events;
using Viper.Utilities;
using ViperModManagers.Utilities;

[assembly: AssemblyCompany("einherjars_client")]
[assembly: AssemblyInformationalVersion("1.0.0+09a98c9d1b47712d6873a8b7db7a81a4310cd4c9")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyConfiguration("Release")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyProduct("einherjars_client")]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyTitle("einherjars_client")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: <2c0e20ab-0c54-4231-8508-d38b3fcbb52c>RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[<25b21cd5-6e8a-481e-9b01-a13fd4a3dc43>Embedded]
	[CompilerGenerated]
	internal sealed class <25b21cd5-6e8a-481e-9b01-a13fd4a3dc43>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<25b21cd5-6e8a-481e-9b01-a13fd4a3dc43>Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class <2c0e20ab-0c54-4231-8508-d38b3fcbb52c>RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public <2c0e20ab-0c54-4231-8508-d38b3fcbb52c>RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[HarmonyPatch(typeof(Character), "Awake")]
public static class CharacterAwakePatch
{
	[CompilerGenerated]
	private sealed class <ApplyTerritoryStars>d__1 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Character __instance;

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

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

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

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

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = null;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>2__current = null;
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					if (TerritoryManager.Territories == null || TerritoryManager.Territories.Count == 0)
					{
						return false;
					}
					MarketplaceTerritory territoryAt = TerritoryManager.GetTerritoryAt(((UnityEngine.Component)(object)__instance).transform.position);
					if (territoryAt == null)
					{
						return false;
					}
					if (territoryAt.AddStars <= 0)
					{
						return false;
					}
					if ((UnityEngine.Object)(object)__instance.m_nview == null || !__instance.m_nview.IsValid())
					{
						return false;
					}
					__instance.GetLevel();
					if ((UnityEngine.Object)(object)__instance.m_nview != null && __instance.m_nview.IsValid())
					{
						ZDO zDO = __instance.m_nview.GetZDO();
						if (zDO != null)
						{
							zDO.Set("creatureLevel", territoryAt.AddStars);
						}
					}
					__instance.SetLevel(territoryAt.AddStars);
				}
				catch (Exception arg)
				{
					EventManager.RaiseLog(new Dictionary<string, object> { ["message"] = $"[TerritoryStars] ❌ Exception in Character.Awake patch:\n{arg}" });
				}
				return false;
			}
		}

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

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

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

	[IteratorStateMachine(typeof(<ApplyTerritoryStars>d__1))]
	private static IEnumerator ApplyTerritoryStars(Character __instance)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ApplyTerritoryStars>d__1(0)
		{
			__instance = __instance
		};
	}
}
[HarmonyPatch(typeof(Player), "OnSpawned")]
public static class Player_OnSpawned_DisplayNamePatch
{
	[CompilerGenerated]
	private sealed class <WaitAndSendDisplayName>d__1 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Player player;

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

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

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

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

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = new WaitForSeconds(1f);
				<>1__state = 1;
				return true;
			case 1:
			{
				<>1__state = -1;
				string hostName = HelreidManager.peer.m_socket.GetHostName();
				hostName = (hostName.StartsWith("Steam_") ? hostName.Substring(6) : hostName);
				string playerName = player.GetPlayerName();
				if (string.IsNullOrEmpty(hostName) || string.IsNullOrEmpty(playerName))
				{
					UnityEngine.Debug.LogWarning("[DisplayNamePatch] ❌ Missing steamId or displayName");
					return false;
				}
				UnityEngine.Debug.Log("[DisplayNamePatch] ✅ Sending SteamID: " + hostName + ", DisplayName: " + playerName);
				SendDisplayNameToBackend(hostName, playerName);
				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(Player __instance)
	{
		if (!((UnityEngine.Object)(object)__instance != (UnityEngine.Object)(object)Player.m_localPlayer))
		{
			((MonoBehaviour)(object)__instance).StartCoroutine(WaitAndSendDisplayName(__instance));
		}
	}

	[IteratorStateMachine(typeof(<WaitAndSendDisplayName>d__1))]
	private static IEnumerator WaitAndSendDisplayName(Player player)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <WaitAndSendDisplayName>d__1(0)
		{
			player = player
		};
	}

	private static async Task SendDisplayNameToBackend(string steamId, string displayName)
	{
		try
		{
			StringContent val = new StringContent(JsonConvert.SerializeObject(new
			{
				steam_id = steamId,
				display_name = displayName
			}), Encoding.UTF8, "application/json");
			HttpClient client = new HttpClient();
			try
			{
				HttpResponseMessage val2 = await client.PostAsync("https://api.einherjarslegacy.com/v1/api/update-display-name", (HttpContent)(object)val);
				if (!val2.IsSuccessStatusCode)
				{
					UnityEngine.Debug.LogWarning($"[DisplayNamePatch] ❌ Failed to update display name: {val2.StatusCode}");
				}
				else
				{
					UnityEngine.Debug.Log("[DisplayNamePatch] ✅ Display name updated.");
				}
			}
			finally
			{
				((IDisposable)client)?.Dispose();
			}
		}
		catch (Exception arg)
		{
			UnityEngine.Debug.LogError($"[DisplayNamePatch] ❌ Exception: {arg}");
		}
	}
}
public static class TaskExtensions
{
	[CompilerGenerated]
	private sealed class <AsIEnumerator>d__0 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Task task;

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

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

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

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

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

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

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

	[IteratorStateMachine(typeof(<AsIEnumerator>d__0))]
	public static IEnumerator AsIEnumerator(this Task task)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <AsIEnumerator>d__0(0)
		{
			task = task
		};
	}
}
namespace SteamSync
{
	public static class SteamDisplaySync
	{
		private static readonly string syncEndpoint = "https://api.einherjarslegacy.com/v1/api/upsert-steam-name";

		public static async Task SendSteamDisplayName(string steamId, string displayName)
		{
			try
			{
				string text = JsonConvert.SerializeObject(new
				{
					steam_id = steamId,
					display_name = displayName
				});
				HttpClient client = new HttpClient();
				try
				{
					StringContent val = new StringContent(text, Encoding.UTF8, "application/json");
					HttpResponseMessage val2 = await client.PostAsync(syncEndpoint, (HttpContent)(object)val);
					if (!val2.IsSuccessStatusCode)
					{
						UnityEngine.Debug.LogWarning($"[SteamDisplaySync] ❌ Failed to sync name: {val2.StatusCode}");
					}
					else
					{
						UnityEngine.Debug.Log("[SteamDisplaySync] ✅ Sent Steam Name '" + displayName + "' for " + steamId);
					}
				}
				finally
				{
					((IDisposable)client)?.Dispose();
				}
			}
			catch (Exception arg)
			{
				UnityEngine.Debug.LogError($"[SteamDisplaySync] ❌ Exception during sync: {arg}");
			}
		}
	}
}
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);
		}
	}
	public static class StableHashExtensions
	{
		public static int GetStableHashCode(this string str)
		{
			int num = 23;
			foreach (char c in str)
			{
				num = num * 31 + c;
			}
			return num;
		}
	}
}
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.Helreid
{
	[BepInPlugin("helreid.bepinex.plugins.einherjarslegacy", "EinherjarsLegacyClient", "1.2.0")]
	public class HelreidManager : BaseUnityPlugin
	{
		public const string ModName = "EinherjarsLegacyClient";

		public const string ModVersion = "1.2.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 static ZNetPeer peer;

		public Harmony harmony;

		private bool reloadItems;

		private string percentageDownload = "";

		private Coroutine _slotInitCoroutine;

		private GameObject _lastProfileUI;

		private GameObject _lastEffectsContent;

		private float _nextEffectsInject;

		public static readonly Dictionary<int, string> PrefabHashToName = new Dictionary<int, string>();

		public static readonly Dictionary<string, GameObject> NameToPrefab = new Dictionary<string, GameObject>();

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

		private void IsBackpackOpen(bool value)
		{
		}

		private void LogThis(Dictionary<string, object> args)
		{
			if (args.ContainsKey("message"))
			{
				string text = (string)args["message"];
				((BaseUnityPlugin)this).Logger.LogInfo((object)text);
			}
		}

		private void PlayerConnected(Dictionary<string, object> args)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			if (args.ContainsKey("peer"))
			{
				EventManager.OnPlayerConnected -= PlayerConnected;
				peer = (ZNetPeer)args["peer"];
				if (steamId.StringsAreEqual("0"))
				{
					Jotunn.Logger.LogInfo("[SetPlayerCustomData] Steam Id is 0 abort. Client not logged in with steam.");
					ZNet.instance.Disconnect(peer);
				}
			}
		}
	}
}
namespace Viper.Utilities
{
	public class CommonUtilities
	{
		public byte[] AddHeader(byte[] data)
		{
			byte[] bytes = BitConverter.GetBytes(data.Length);
			return CombineTwoArrays(bytes, data);
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public delegate void PassObject(object source);

		public delegate void PassNothing();

		public delegate void PassString(string value);

		public delegate void PassBool(bool 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 event PassBool OnIsBackpackOpen;

		public static void RaiseIsBackpackOpen(bool isOpen)
		{
			if (EventManager.OnIsBackpackOpen != null)
			{
				EventManager.OnIsBackpackOpen(isOpen);
			}
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public string X;

		public string Z;

		public string Radius;

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

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

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

		private static CancellationTokenSource _cts = new CancellationTokenSource();

		private static bool _started = false;

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


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

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

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

		public static void StopAutoRefresh()
		{
			_cts.Cancel();
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<50c2e9d6-4a04-4998-aa50-ac54fd81f726>Embedded]
	internal sealed class <50c2e9d6-4a04-4998-aa50-ac54fd81f726>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<50c2e9d6-4a04-4998-aa50-ac54fd81f726>Embedded]
	internal sealed class <df4da661-52fc-439b-a889-793553a96248>IsReadOnlyAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<50c2e9d6-4a04-4998-aa50-ac54fd81f726>Embedded]
	internal sealed class <d48348d9-b1b8-412b-b01c-b7d134446496>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <d48348d9-b1b8-412b-b01c-b7d134446496>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <d48348d9-b1b8-412b-b01c-b7d134446496>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[<50c2e9d6-4a04-4998-aa50-ac54fd81f726>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	internal sealed class <d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <d46f6e76-b900-43b0-8b05-94a67ad15f2e>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
	}
	[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
	[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(0)]
	internal class DefaultJsonNameTable : JsonNameTable
	{
		[<d48348d9-b1b8-412b-b01c-b7d134446496>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: <d48348d9-b1b8-412b-b01c-b7d134446496>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
	}
	[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
	internal interface IArrayPool<[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] T>
	{
		T[] Rent(int minimumLength);

		void Return([<d48348d9-b1b8-412b-b01c-b7d134446496>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;
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		public JsonArrayAttribute(string id)
			: base(id)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false)]
	internal sealed class JsonConstructorAttribute : Attribute
	{
	}
	[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
	[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(0)]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
	internal abstract class JsonContainerAttribute : Attribute
	{
		internal bool? _isReference;

		internal bool? _itemIsReference;

		internal ReferenceLoopHandling? _itemReferenceLoopHandling;

		internal TypeNameHandling? _itemTypeNameHandling;

		private Type _namingStrategyType;

		[<d48348d9-b1b8-412b-b01c-b7d134446496>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; }

		[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
		[field: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
		public object[] ItemConverterParameters
		{
			[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
			get;
			[param: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
			set;
		}

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

		[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
		public object[] NamingStrategyParameters
		{
			[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
			get
			{
				return _namingStrategyParameters;
			}
			[param: <d48348d9-b1b8-412b-b01c-b7d134446496>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()
		{
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		protected JsonContainerAttribute(string id)
		{
			Id = id;
		}
	}
	[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(0)]
	[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
	internal static class JsonConvert
	{
		public static readonly string True = "true";

		public static readonly string False = "false";

		public static readonly string Null = "null";

		public static readonly string Undefined = "undefined";

		public static readonly string PositiveInfinity = "Infinity";

		public static readonly string NegativeInfinity = "-Infinity";

		public static readonly string NaN = "NaN";

		[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
		[field: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
		public static Func<JsonSerializerSettings> DefaultSettings
		{
			[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
			get;
			[param: <d48348d9-b1b8-412b-b01c-b7d134446496>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 = Newtonsoft.Json.Utilities.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 = Newtonsoft.Json.Utilities.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) || Newtonsoft.Json.Utilities.StringUtils.IndexOf(text, '.') != -1 || Newtonsoft.Json.Utilities.StringUtils.IndexOf(text, 'E') != -1 || Newtonsoft.Json.Utilities.StringUtils.IndexOf(text, 'e') != -1)
			{
				return text;
			}
			return text + ".0";
		}

		private static string EnsureDecimalPlace(string text)
		{
			if (Newtonsoft.Json.Utilities.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([<d48348d9-b1b8-412b-b01c-b7d134446496>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([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] string value)
		{
			return ToString(value, '"');
		}

		public static string ToString([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] string value, char delimiter)
		{
			return ToString(value, delimiter, StringEscapeHandling.Default);
		}

		public static string ToString([<d48348d9-b1b8-412b-b01c-b7d134446496>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([<d48348d9-b1b8-412b-b01c-b7d134446496>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([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] object value)
		{
			return SerializeObject(value, (Type)null, (JsonSerializerSettings)null);
		}

		[DebuggerStepThrough]
		public static string SerializeObject([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] object value, Formatting formatting)
		{
			return SerializeObject(value, formatting, (JsonSerializerSettings)null);
		}

		[DebuggerStepThrough]
		public static string SerializeObject([<d48348d9-b1b8-412b-b01c-b7d134446496>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([<d48348d9-b1b8-412b-b01c-b7d134446496>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);
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
		[DebuggerStepThrough]
		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(1)]
		public static string SerializeObject(object value, JsonSerializerSettings settings)
		{
			return SerializeObject(value, null, settings);
		}

		[DebuggerStepThrough]
		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(1)]
		public static string SerializeObject(object value, Type type, JsonSerializerSettings settings)
		{
			JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
			return SerializeObjectInternal(value, type, jsonSerializer);
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
		[DebuggerStepThrough]
		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(1)]
		public static string SerializeObject(object value, Formatting formatting, JsonSerializerSettings settings)
		{
			return SerializeObject(value, null, formatting, settings);
		}

		[DebuggerStepThrough]
		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>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([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] object value, [<d48348d9-b1b8-412b-b01c-b7d134446496>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: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)]
		public static object DeserializeObject(string value)
		{
			return DeserializeObject(value, (Type)null, (JsonSerializerSettings)null);
		}

		[DebuggerStepThrough]
		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)]
		public static object DeserializeObject(string value, JsonSerializerSettings settings)
		{
			return DeserializeObject(value, null, settings);
		}

		[DebuggerStepThrough]
		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)]
		public static object DeserializeObject(string value, Type type)
		{
			return DeserializeObject(value, type, (JsonSerializerSettings)null);
		}

		[DebuggerStepThrough]
		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
		public static T DeserializeObject<T>([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(1)] string value)
		{
			return JsonConvert.DeserializeObject<T>(value, (JsonSerializerSettings)null);
		}

		[DebuggerStepThrough]
		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)]
		public static T DeserializeAnonymousType<[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] T>(string value, T anonymousTypeObject)
		{
			return DeserializeObject<T>(value);
		}

		[DebuggerStepThrough]
		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)]
		public static T DeserializeAnonymousType<[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] T>(string value, T anonymousTypeObject, JsonSerializerSettings settings)
		{
			return DeserializeObject<T>(value, settings);
		}

		[DebuggerStepThrough]
		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)]
		public static T DeserializeObject<[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] T>(string value, params JsonConverter[] converters)
		{
			return (T)DeserializeObject(value, typeof(T), converters);
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
		[DebuggerStepThrough]
		public static T DeserializeObject<T>([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(1)] string value, JsonSerializerSettings settings)
		{
			return (T)DeserializeObject(value, typeof(T), settings);
		}

		[DebuggerStepThrough]
		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>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);
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
		public static object DeserializeObject([<d48348d9-b1b8-412b-b01c-b7d134446496>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, [<d48348d9-b1b8-412b-b01c-b7d134446496>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([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] XmlNode node)
		{
			return SerializeXmlNode(node, Formatting.None);
		}

		public static string SerializeXmlNode([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] XmlNode node, Formatting formatting)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		public static string SerializeXmlNode([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] XmlNode node, Formatting formatting, bool omitRootObject)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
			{
				OmitRootObject = omitRootObject
			};
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)]
		public static XmlDocument DeserializeXmlNode(string value)
		{
			return DeserializeXmlNode(value, null);
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
		public static XmlDocument DeserializeXmlNode([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(1)] string value, string deserializeRootElementName)
		{
			return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute: false);
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
		public static XmlDocument DeserializeXmlNode([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(1)] string value, string deserializeRootElementName, bool writeArrayAttribute)
		{
			return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
		public static XmlDocument DeserializeXmlNode([<d48348d9-b1b8-412b-b01c-b7d134446496>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([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] XObject node)
		{
			return SerializeXNode(node, Formatting.None);
		}

		public static string SerializeXNode([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] XObject node, Formatting formatting)
		{
			return SerializeXNode(node, formatting, omitRootObject: false);
		}

		public static string SerializeXNode([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] XObject node, Formatting formatting, bool omitRootObject)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
			{
				OmitRootObject = omitRootObject
			};
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)]
		public static XDocument DeserializeXNode(string value)
		{
			return DeserializeXNode(value, null);
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
		public static XDocument DeserializeXNode([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(1)] string value, string deserializeRootElementName)
		{
			return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute: false);
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
		public static XDocument DeserializeXNode([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(1)] string value, string deserializeRootElementName, bool writeArrayAttribute)
		{
			return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
		public static XDocument DeserializeXNode([<d48348d9-b1b8-412b-b01c-b7d134446496>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);
		}
	}
	[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
	[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(0)]
	internal abstract class JsonConverter
	{
		public virtual bool CanRead => true;

		public virtual bool CanWrite => true;

		public abstract void WriteJson(JsonWriter writer, [<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] object value, JsonSerializer serializer);

		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)]
		public abstract object ReadJson(JsonReader reader, Type objectType, [<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] object existingValue, JsonSerializer serializer);

		public abstract bool CanConvert(Type objectType);
	}
	[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
	[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(0)]
	internal abstract class JsonConverter<[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] T> : JsonConverter
	{
		public sealed override void WriteJson(JsonWriter writer, [<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] object value, JsonSerializer serializer)
		{
			if (!((value != null) ? (value is T) : Newtonsoft.Json.Utilities.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, [<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] T value, JsonSerializer serializer);

		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)]
		public sealed override object ReadJson(JsonReader reader, Type objectType, [<d48348d9-b1b8-412b-b01c-b7d134446496>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: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)]
		public abstract T ReadJson(JsonReader reader, Type objectType, [<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] T existingValue, bool hasExistingValue, JsonSerializer serializer);

		public sealed override bool CanConvert(Type objectType)
		{
			return typeof(T).IsAssignableFrom(objectType);
		}
	}
	[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
	[<d48348d9-b1b8-412b-b01c-b7d134446496>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;

		[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
		[field: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
		public object[] ConverterParameters
		{
			[return: <d48348d9-b1b8-412b-b01c-b7d134446496>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;
		}
	}
	[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 0, 1 })]
	internal class JsonConverterCollection : Collection<JsonConverter>
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
	internal sealed class JsonDictionaryAttribute : JsonContainerAttribute
	{
		public JsonDictionaryAttribute()
		{
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		public JsonDictionaryAttribute(string id)
			: base(id)
		{
		}
	}
	[Serializable]
	[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
	[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(0)]
	internal class JsonException : Exception
	{
		public JsonException()
		{
		}

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

		public JsonException(string message, [<d48348d9-b1b8-412b-b01c-b7d134446496>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
	{
		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>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;
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		public JsonObjectAttribute(string id)
			: base(id)
		{
		}
	}
	internal enum JsonContainerType
	{
		None,
		Object,
		Array,
		Constructor
	}
	[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
	[<d48348d9-b1b8-412b-b01c-b7d134446496>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;

		[<d48348d9-b1b8-412b-b01c-b7d134446496>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");
			}
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
		internal void WriteTo([<d48348d9-b1b8-412b-b01c-b7d134446496>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([<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(2)] IJsonLineInfo lineInfo, string path, string message)
		{
			if (!message.EndsWith(Environment.NewLine, StringComparison.Ordinal))
			{
				message = message.Trim();
				if (!Newtonsoft.Json.Utilities.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;
		}
	}
	[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false)]
	[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(0)]
	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; }

		[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
		[field: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
		public object[] ItemConverterParameters
		{
			[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
			get;
			[param: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
			set;
		}

		public Type NamingStrategyType { get; set; }

		[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
		[field: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
		public object[] NamingStrategyParameters
		{
			[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 2, 1 })]
			get;
			[param: <d48348d9-b1b8-412b-b01c-b7d134446496>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()
		{
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		public JsonPropertyAttribute(string propertyName)
		{
			PropertyName = propertyName;
		}
	}
	[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(2)]
	[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(0)]
	internal abstract class JsonReader : IDisposable
	{
		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>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;
			}
		}

		[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(1)]
		public virtual string Path
		{
			[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>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);
			}
		}

		[<d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(1)]
		public CultureInfo Culture
		{
			[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
			get
			{
				return _culture ?? CultureInfo.InvariantCulture;
			}
			[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
			set
			{
				_culture = value;
			}
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		public virtual Task<bool> ReadAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<bool>() ?? Read().ToAsync();
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>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)
				{
				}
			}
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		internal async Task ReaderReadAndAssertAsync(CancellationToken cancellationToken)
		{
			if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
			{
				throw CreateUnexpectedEndException();
			}
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		public virtual Task<bool?> ReadAsBooleanAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<bool?>() ?? Task.FromResult(ReadAsBoolean());
		}

		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 1, 2 })]
		public virtual Task<byte[]> ReadAsBytesAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<byte[]>() ?? Task.FromResult(ReadAsBytes());
		}

		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>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;
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		public virtual Task<DateTime?> ReadAsDateTimeAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<DateTime?>() ?? Task.FromResult(ReadAsDateTime());
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		public virtual Task<DateTimeOffset?> ReadAsDateTimeOffsetAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<DateTimeOffset?>() ?? Task.FromResult(ReadAsDateTimeOffset());
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		public virtual Task<decimal?> ReadAsDecimalAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<decimal?>() ?? Task.FromResult(ReadAsDecimal());
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		public virtual Task<double?> ReadAsDoubleAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return Task.FromResult(ReadAsDouble());
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		public virtual Task<int?> ReadAsInt32Async(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<int?>() ?? Task.FromResult(ReadAsInt32());
		}

		[return: <d48348d9-b1b8-412b-b01c-b7d134446496>Nullable(new byte[] { 1, 2 })]
		public virtual Task<string> ReadAsStringAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<string>() ?? Task.FromResult(ReadAsString());
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>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;
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>NullableContext(1)]
		internal Task<bool> MoveToContentAsync(CancellationToken cancellationToken)
		{
			JsonToken tokenType = TokenType;
			if (tokenType == JsonToken.None || tokenType == JsonToken.Comment)
			{
				return MoveToContentFromNonContentAsync(cancellationToken);
			}
			return AsyncUtils.True;
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>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 (Newtonsoft.Json.Utilities.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));
			}
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>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;
		}

		[<d46f6e76-b900-43b0-8b05-94a67ad15f2e>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