using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: CLSCompliant(true)]
[assembly: AssemblyTitle("LitJson")]
[assembly: AssemblyDescription("LitJSON library")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LitJSON")]
[assembly: AssemblyCopyright("The authors disclaim copyright to this source code")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyInformationalVersion("0.10.0+Branch.master.Sha.0f970e2472e9207157d80e6b2921b231943dd784")]
[assembly: AssemblyFileVersion("0.10.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.5", FrameworkDisplayName = ".NET Framework 4.5")]
[assembly: AssemblyVersion("0.10.0.0")]
namespace LitJson;

public enum JsonType
{
	None,
	Object,
	Array,
	String,
	Int,
	Long,
	Double,
	Boolean
}
public interface IJsonWrapper : IList, ICollection, IEnumerable, IOrderedDictionary, IDictionary
{
	bool IsArray { get; }

	bool IsBoolean { get; }

	bool IsDouble { get; }

	bool IsInt { get; }

	bool IsLong { get; }

	bool IsObject { get; }

	bool IsString { get; }

	bool GetBoolean();

	double GetDouble();

	int GetInt();

	JsonType GetJsonType();

	long GetLong();

	string GetString();

	void SetBoolean(bool val);

	void SetDouble(double val);

	void SetInt(int val);

	void SetJsonType(JsonType type);

	void SetLong(long val);

	void SetString(string val);

	string ToJson();

	void ToJson(JsonWriter writer);
}
public class JsonData : IJsonWrapper, IList, ICollection, IEnumerable, IOrderedDictionary, IDictionary, IEquatable<JsonData>
{
	private IList<JsonData> inst_array;

	private bool inst_boolean;

	private double inst_double;

	private int inst_int;

	private long inst_long;

	private IDictionary<string, JsonData> inst_object;

	private string inst_string;

	private string json;

	private JsonType type;

	private IList<KeyValuePair<string, JsonData>> object_list;

	public int Count => EnsureCollection().Count;

	public bool IsArray => type == JsonType.Array;

	public bool IsBoolean => type == JsonType.Boolean;

	public bool IsDouble => type == JsonType.Double;

	public bool IsInt => type == JsonType.Int;

	public bool IsLong => type == JsonType.Long;

	public bool IsObject => type == JsonType.Object;

	public bool IsString => type == JsonType.String;

	public ICollection<string> Keys
	{
		get
		{
			EnsureDictionary();
			return inst_object.Keys;
		}
	}

	int ICollection.Count => Count;

	bool ICollection.IsSynchronized => EnsureCollection().IsSynchronized;

	object ICollection.SyncRoot => EnsureCollection().SyncRoot;

	bool IDictionary.IsFixedSize => EnsureDictionary().IsFixedSize;

	bool IDictionary.IsReadOnly => EnsureDictionary().IsReadOnly;

	ICollection IDictionary.Keys
	{
		get
		{
			EnsureDictionary();
			IList<string> list = new List<string>();
			foreach (KeyValuePair<string, JsonData> item in object_list)
			{
				list.Add(item.Key);
			}
			return (ICollection)list;
		}
	}

	ICollection IDictionary.Values
	{
		get
		{
			EnsureDictionary();
			IList<JsonData> list = new List<JsonData>();
			foreach (KeyValuePair<string, JsonData> item in object_list)
			{
				list.Add(item.Value);
			}
			return (ICollection)list;
		}
	}

	bool IJsonWrapper.IsArray => IsArray;

	bool IJsonWrapper.IsBoolean => IsBoolean;

	bool IJsonWrapper.IsDouble => IsDouble;

	bool IJsonWrapper.IsInt => IsInt;

	bool IJsonWrapper.IsLong => IsLong;

	bool IJsonWrapper.IsObject => IsObject;

	bool IJsonWrapper.IsString => IsString;

	bool IList.IsFixedSize => EnsureList().IsFixedSize;

	bool IList.IsReadOnly => EnsureList().IsReadOnly;

	object IDictionary.this[object key]
	{
		get
		{
			return EnsureDictionary()[key];
		}
		set
		{
			if (!(key is string))
			{
				throw new ArgumentException("The key has to be a string");
			}
			JsonData value2 = ToJsonData(value);
			this[(string)key] = value2;
		}
	}

	object IOrderedDictionary.this[int idx]
	{
		get
		{
			EnsureDictionary();
			return object_list[idx].Value;
		}
		set
		{
			EnsureDictionary();
			JsonData value2 = ToJsonData(value);
			KeyValuePair<string, JsonData> keyValuePair = object_list[idx];
			inst_object[keyValuePair.Key] = value2;
			KeyValuePair<string, JsonData> value3 = new KeyValuePair<string, JsonData>(keyValuePair.Key, value2);
			object_list[idx] = value3;
		}
	}

	object IList.this[int index]
	{
		get
		{
			return EnsureList()[index];
		}
		set
		{
			EnsureList();
			JsonData value2 = ToJsonData(value);
			this[index] = value2;
		}
	}

	public JsonData this[string prop_name]
	{
		get
		{
			EnsureDictionary();
			return inst_object[prop_name];
		}
		set
		{
			EnsureDictionary();
			KeyValuePair<string, JsonData> keyValuePair = new KeyValuePair<string, JsonData>(prop_name, value);
			if (inst_object.ContainsKey(prop_name))
			{
				for (int i = 0; i < object_list.Count; i++)
				{
					if (object_list[i].Key == prop_name)
					{
						object_list[i] = keyValuePair;
						break;
					}
				}
			}
			else
			{
				object_list.Add(keyValuePair);
			}
			inst_object[prop_name] = value;
			json = null;
		}
	}

	public JsonData this[int index]
	{
		get
		{
			EnsureCollection();
			if (type == JsonType.Array)
			{
				return inst_array[index];
			}
			return object_list[index].Value;
		}
		set
		{
			EnsureCollection();
			if (type == JsonType.Array)
			{
				inst_array[index] = value;
			}
			else
			{
				KeyValuePair<string, JsonData> keyValuePair = object_list[index];
				KeyValuePair<string, JsonData> value2 = new KeyValuePair<string, JsonData>(keyValuePair.Key, value);
				object_list[index] = value2;
				inst_object[keyValuePair.Key] = value;
			}
			json = null;
		}
	}

	public JsonData()
	{
	}

	public JsonData(bool boolean)
	{
		type = JsonType.Boolean;
		inst_boolean = boolean;
	}

	public JsonData(double number)
	{
		type = JsonType.Double;
		inst_double = number;
	}

	public JsonData(int number)
	{
		type = JsonType.Int;
		inst_int = number;
	}

	public JsonData(long number)
	{
		type = JsonType.Long;
		inst_long = number;
	}

	public JsonData(object obj)
	{
		if (obj is bool)
		{
			type = JsonType.Boolean;
			inst_boolean = (bool)obj;
			return;
		}
		if (obj is double)
		{
			type = JsonType.Double;
			inst_double = (double)obj;
			return;
		}
		if (obj is int)
		{
			type = JsonType.Int;
			inst_int = (int)obj;
			return;
		}
		if (obj is long)
		{
			type = JsonType.Long;
			inst_long = (long)obj;
			return;
		}
		if (obj is string)
		{
			type = JsonType.String;
			inst_string = (string)obj;
			return;
		}
		throw new ArgumentException("Unable to wrap the given object with JsonData");
	}

	public JsonData(string str)
	{
		type = JsonType.String;
		inst_string = str;
	}

	public static implicit operator JsonData(bool data)
	{
		return new JsonData(data);
	}

	public static implicit operator JsonData(double data)
	{
		return new JsonData(data);
	}

	public static implicit operator JsonData(int data)
	{
		return new JsonData(data);
	}

	public static implicit operator JsonData(long data)
	{
		return new JsonData(data);
	}

	public static implicit operator JsonData(string data)
	{
		return new JsonData(data);
	}

	public static explicit operator bool(JsonData data)
	{
		if (data.type != JsonType.Boolean)
		{
			throw new InvalidCastException("Instance of JsonData doesn't hold a double");
		}
		return data.inst_boolean;
	}

	public static explicit operator double(JsonData data)
	{
		if (data.type != JsonType.Double)
		{
			throw new InvalidCastException("Instance of JsonData doesn't hold a double");
		}
		return data.inst_double;
	}

	public static explicit operator int(JsonData data)
	{
		if (data.type != JsonType.Int)
		{
			throw new InvalidCastException("Instance of JsonData doesn't hold an int");
		}
		return data.inst_int;
	}

	public static explicit operator long(JsonData data)
	{
		if (data.type != JsonType.Long && data.type != JsonType.Int)
		{
			throw new InvalidCastException("Instance of JsonData doesn't hold an int");
		}
		if (data.type != JsonType.Long)
		{
			return data.inst_int;
		}
		return data.inst_long;
	}

	public static explicit operator string(JsonData data)
	{
		if (data.type != JsonType.String)
		{
			throw new InvalidCastException("Instance of JsonData doesn't hold a string");
		}
		return data.inst_string;
	}

	void ICollection.CopyTo(Array array, int index)
	{
		EnsureCollection().CopyTo(array, index);
	}

	void IDictionary.Add(object key, object value)
	{
		JsonData value2 = ToJsonData(value);
		EnsureDictionary().Add(key, value2);
		KeyValuePair<string, JsonData> item = new KeyValuePair<string, JsonData>((string)key, value2);
		object_list.Add(item);
		json = null;
	}

	void IDictionary.Clear()
	{
		EnsureDictionary().Clear();
		object_list.Clear();
		json = null;
	}

	bool IDictionary.Contains(object key)
	{
		return EnsureDictionary().Contains(key);
	}

	IDictionaryEnumerator IDictionary.GetEnumerator()
	{
		return ((IOrderedDictionary)this).GetEnumerator();
	}

	void IDictionary.Remove(object key)
	{
		EnsureDictionary().Remove(key);
		for (int i = 0; i < object_list.Count; i++)
		{
			if (object_list[i].Key == (string)key)
			{
				object_list.RemoveAt(i);
				break;
			}
		}
		json = null;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return EnsureCollection().GetEnumerator();
	}

	bool IJsonWrapper.GetBoolean()
	{
		if (type != JsonType.Boolean)
		{
			throw new InvalidOperationException("JsonData instance doesn't hold a boolean");
		}
		return inst_boolean;
	}

	double IJsonWrapper.GetDouble()
	{
		if (type != JsonType.Double)
		{
			throw new InvalidOperationException("JsonData instance doesn't hold a double");
		}
		return inst_double;
	}

	int IJsonWrapper.GetInt()
	{
		if (type != JsonType.Int)
		{
			throw new InvalidOperationException("JsonData instance doesn't hold an int");
		}
		return inst_int;
	}

	long IJsonWrapper.GetLong()
	{
		if (type != JsonType.Long)
		{
			throw new InvalidOperationException("JsonData instance doesn't hold a long");
		}
		return inst_long;
	}

	string IJsonWrapper.GetString()
	{
		if (type != JsonType.String)
		{
			throw new InvalidOperationException("JsonData instance doesn't hold a string");
		}
		return inst_string;
	}

	void IJsonWrapper.SetBoolean(bool val)
	{
		type = JsonType.Boolean;
		inst_boolean = val;
		json = null;
	}

	void IJsonWrapper.SetDouble(double val)
	{
		type = JsonType.Double;
		inst_double = val;
		json = null;
	}

	void IJsonWrapper.SetInt(int val)
	{
		type = JsonType.Int;
		inst_int = val;
		json = null;
	}

	void IJsonWrapper.SetLong(long val)
	{
		type = JsonType.Long;
		inst_long = val;
		json = null;
	}

	void IJsonWrapper.SetString(string val)
	{
		type = JsonType.String;
		inst_string = val;
		json = null;
	}

	string IJsonWrapper.ToJson()
	{
		return ToJson();
	}

	void IJsonWrapper.ToJson(JsonWriter writer)
	{
		ToJson(writer);
	}

	int IList.Add(object value)
	{
		return Add(value);
	}

	void IList.Clear()
	{
		EnsureList().Clear();
		json = null;
	}

	bool IList.Contains(object value)
	{
		return EnsureList().Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return EnsureList().IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		EnsureList().Insert(index, value);
		json = null;
	}

	void IList.Remove(object value)
	{
		EnsureList().Remove(value);
		json = null;
	}

	void IList.RemoveAt(int index)
	{
		EnsureList().RemoveAt(index);
		json = null;
	}

	IDictionaryEnumerator IOrderedDictionary.GetEnumerator()
	{
		EnsureDictionary();
		return new OrderedDictionaryEnumerator(object_list.GetEnumerator());
	}

	void IOrderedDictionary.Insert(int idx, object key, object value)
	{
		string text = (string)key;
		JsonData value2 = (this[text] = ToJsonData(value));
		KeyValuePair<string, JsonData> item = new KeyValuePair<string, JsonData>(text, value2);
		object_list.Insert(idx, item);
	}

	void IOrderedDictionary.RemoveAt(int idx)
	{
		EnsureDictionary();
		inst_object.Remove(object_list[idx].Key);
		object_list.RemoveAt(idx);
	}

	private ICollection EnsureCollection()
	{
		if (type == JsonType.Array)
		{
			return (ICollection)inst_array;
		}
		if (type == JsonType.Object)
		{
			return (ICollection)inst_object;
		}
		throw new InvalidOperationException("The JsonData instance has to be initialized first");
	}

	private IDictionary EnsureDictionary()
	{
		if (type == JsonType.Object)
		{
			return (IDictionary)inst_object;
		}
		if (type != 0)
		{
			throw new InvalidOperationException("Instance of JsonData is not a dictionary");
		}
		type = JsonType.Object;
		inst_object = new Dictionary<string, JsonData>();
		object_list = new List<KeyValuePair<string, JsonData>>();
		return (IDictionary)inst_object;
	}

	private IList EnsureList()
	{
		if (type == JsonType.Array)
		{
			return (IList)inst_array;
		}
		if (type != 0)
		{
			throw new InvalidOperationException("Instance of JsonData is not a list");
		}
		type = JsonType.Array;
		inst_array = new List<JsonData>();
		return (IList)inst_array;
	}

	private JsonData ToJsonData(object obj)
	{
		if (obj == null)
		{
			return null;
		}
		if (obj is JsonData)
		{
			return (JsonData)obj;
		}
		return new JsonData(obj);
	}

	private static void WriteJson(IJsonWrapper obj, JsonWriter writer)
	{
		if (obj == null)
		{
			writer.Write(null);
		}
		else if (obj.IsString)
		{
			writer.Write(obj.GetString());
		}
		else if (obj.IsBoolean)
		{
			writer.Write(obj.GetBoolean());
		}
		else if (obj.IsDouble)
		{
			writer.Write(obj.GetDouble());
		}
		else if (obj.IsInt)
		{
			writer.Write(obj.GetInt());
		}
		else if (obj.IsLong)
		{
			writer.Write(obj.GetLong());
		}
		else if (obj.IsArray)
		{
			writer.WriteArrayStart();
			foreach (JsonData item in (IEnumerable)obj)
			{
				WriteJson(item, writer);
			}
			writer.WriteArrayEnd();
		}
		else
		{
			if (!obj.IsObject)
			{
				return;
			}
			writer.WriteObjectStart();
			foreach (DictionaryEntry item2 in (IDictionary)obj)
			{
				writer.WritePropertyName((string)item2.Key);
				WriteJson((JsonData)item2.Value, writer);
			}
			writer.WriteObjectEnd();
		}
	}

	public int Add(object value)
	{
		JsonData value2 = ToJsonData(value);
		json = null;
		return EnsureList().Add(value2);
	}

	public void Clear()
	{
		if (IsObject)
		{
			((IDictionary)this).Clear();
		}
		else if (IsArray)
		{
			((IList)this).Clear();
		}
	}

	public bool Equals(JsonData x)
	{
		if (x == null)
		{
			return false;
		}
		if (x.type != type)
		{
			return false;
		}
		return type switch
		{
			JsonType.None => true, 
			JsonType.Object => inst_object.Equals(x.inst_object), 
			JsonType.Array => inst_array.Equals(x.inst_array), 
			JsonType.String => inst_string.Equals(x.inst_string), 
			JsonType.Int => inst_int.Equals(x.inst_int), 
			JsonType.Long => inst_long.Equals(x.inst_long), 
			JsonType.Double => inst_double.Equals(x.inst_double), 
			JsonType.Boolean => inst_boolean.Equals(x.inst_boolean), 
			_ => false, 
		};
	}

	public JsonType GetJsonType()
	{
		return type;
	}

	public void SetJsonType(JsonType type)
	{
		if (this.type != type)
		{
			switch (type)
			{
			case JsonType.Object:
				inst_object = new Dictionary<string, JsonData>();
				object_list = new List<KeyValuePair<string, JsonData>>();
				break;
			case JsonType.Array:
				inst_array = new List<JsonData>();
				break;
			case JsonType.String:
				inst_string = null;
				break;
			case JsonType.Int:
				inst_int = 0;
				break;
			case JsonType.Long:
				inst_long = 0L;
				break;
			case JsonType.Double:
				inst_double = 0.0;
				break;
			case JsonType.Boolean:
				inst_boolean = false;
				break;
			}
			this.type = type;
		}
	}

	public string ToJson()
	{
		if (json != null)
		{
			return json;
		}
		StringWriter stringWriter = new StringWriter();
		JsonWriter jsonWriter = new JsonWriter(stringWriter);
		jsonWriter.Validate = false;
		WriteJson(this, jsonWriter);
		json = stringWriter.ToString();
		return json;
	}

	public void ToJson(JsonWriter writer)
	{
		bool validate = writer.Validate;
		writer.Validate = false;
		WriteJson(this, writer);
		writer.Validate = validate;
	}

	public override string ToString()
	{
		return type switch
		{
			JsonType.Array => "JsonData array", 
			JsonType.Boolean => inst_boolean.ToString(), 
			JsonType.Double => inst_double.ToString(), 
			JsonType.Int => inst_int.ToString(), 
			JsonType.Long => inst_long.ToString(), 
			JsonType.Object => "JsonData object", 
			JsonType.String => inst_string, 
			_ => "Uninitialized JsonData", 
		};
	}
}
internal class OrderedDictionaryEnumerator : IDictionaryEnumerator, IEnumerator
{
	private IEnumerator<KeyValuePair<string, JsonData>> list_enumerator;

	public object Current => Entry;

	public DictionaryEntry Entry
	{
		get
		{
			KeyValuePair<string, JsonData> current = list_enumerator.Current;
			return new DictionaryEntry(current.Key, current.Value);
		}
	}

	public object Key => list_enumerator.Current.Key;

	public object Value => list_enumerator.Current.Value;

	public OrderedDictionaryEnumerator(IEnumerator<KeyValuePair<string, JsonData>> enumerator)
	{
		list_enumerator = enumerator;
	}

	public bool MoveNext()
	{
		return list_enumerator.MoveNext();
	}

	public void Reset()
	{
		list_enumerator.Reset();
	}
}
public class JsonException : ApplicationException
{
	public JsonException()
	{
	}

	internal JsonException(ParserToken token)
		: base($"Invalid token '{token}' in input string")
	{
	}

	internal JsonException(ParserToken token, Exception inner_exception)
		: base($"Invalid token '{token}' in input string", inner_exception)
	{
	}

	internal JsonException(int c)
		: base($"Invalid character '{(char)c}' in input string")
	{
	}

	internal JsonException(int c, Exception inner_exception)
		: base($"Invalid character '{(char)c}' in input string", inner_exception)
	{
	}

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

	public JsonException(string message, Exception inner_exception)
		: base(message, inner_exception)
	{
	}
}
internal struct PropertyMetadata
{
	public MemberInfo Info;

	public bool IsField;

	public Type Type;
}
internal struct ArrayMetadata
{
	private Type element_type;

	private bool is_array;

	private bool is_list;

	public Type ElementType
	{
		get
		{
			if (element_type == null)
			{
				return typeof(JsonData);
			}
			return element_type;
		}
		set
		{
			element_type = value;
		}
	}

	public bool IsArray
	{
		get
		{
			return is_array;
		}
		set
		{
			is_array = value;
		}
	}

	public bool IsList
	{
		get
		{
			return is_list;
		}
		set
		{
			is_list = value;
		}
	}
}
internal struct ObjectMetadata
{
	private Type element_type;

	private bool is_dictionary;

	private IDictionary<string, PropertyMetadata> properties;

	public Type ElementType
	{
		get
		{
			if (element_type == null)
			{
				return typeof(JsonData);
			}
			return element_type;
		}
		set
		{
			element_type = value;
		}
	}

	public bool IsDictionary
	{
		get
		{
			return is_dictionary;
		}
		set
		{
			is_dictionary = value;
		}
	}

	public IDictionary<string, PropertyMetadata> Properties
	{
		get
		{
			return properties;
		}
		set
		{
			properties = value;
		}
	}
}
internal delegate void ExporterFunc(object obj, JsonWriter writer);
public delegate void ExporterFunc<T>(T obj, JsonWriter writer);
internal delegate object ImporterFunc(object input);
public delegate TValue ImporterFunc<TJson, TValue>(TJson input);
public delegate IJsonWrapper WrapperFactory();
public class JsonMapper
{
	private static readonly int max_nesting_depth;

	private static readonly IFormatProvider datetime_format;

	private static readonly IDictionary<Type, ExporterFunc> base_exporters_table;

	private static readonly IDictionary<Type, ExporterFunc> custom_exporters_table;

	private static readonly IDictionary<Type, IDictionary<Type, ImporterFunc>> base_importers_table;

	private static readonly IDictionary<Type, IDictionary<Type, ImporterFunc>> custom_importers_table;

	private static readonly IDictionary<Type, ArrayMetadata> array_metadata;

	private static readonly object array_metadata_lock;

	private static readonly IDictionary<Type, IDictionary<Type, MethodInfo>> conv_ops;

	private static readonly object conv_ops_lock;

	private static readonly IDictionary<Type, ObjectMetadata> object_metadata;

	private static readonly object object_metadata_lock;

	private static readonly IDictionary<Type, IList<PropertyMetadata>> type_properties;

	private static readonly object type_properties_lock;

	private static readonly JsonWriter static_writer;

	private static readonly object static_writer_lock;

	static JsonMapper()
	{
		array_metadata_lock = new object();
		conv_ops_lock = new object();
		object_metadata_lock = new object();
		type_properties_lock = new object();
		static_writer_lock = new object();
		max_nesting_depth = 100;
		array_metadata = new Dictionary<Type, ArrayMetadata>();
		conv_ops = new Dictionary<Type, IDictionary<Type, MethodInfo>>();
		object_metadata = new Dictionary<Type, ObjectMetadata>();
		type_properties = new Dictionary<Type, IList<PropertyMetadata>>();
		static_writer = new JsonWriter();
		datetime_format = DateTimeFormatInfo.InvariantInfo;
		base_exporters_table = new Dictionary<Type, ExporterFunc>();
		custom_exporters_table = new Dictionary<Type, ExporterFunc>();
		base_importers_table = new Dictionary<Type, IDictionary<Type, ImporterFunc>>();
		custom_importers_table = new Dictionary<Type, IDictionary<Type, ImporterFunc>>();
		RegisterBaseExporters();
		RegisterBaseImporters();
	}

	private static void AddArrayMetadata(Type type)
	{
		if (array_metadata.ContainsKey(type))
		{
			return;
		}
		ArrayMetadata value = default(ArrayMetadata);
		value.IsArray = type.IsArray;
		if (type.GetInterface("System.Collections.IList") != null)
		{
			value.IsList = true;
		}
		PropertyInfo[] properties = type.GetProperties();
		foreach (PropertyInfo propertyInfo in properties)
		{
			if (!(propertyInfo.Name != "Item"))
			{
				ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters();
				if (indexParameters.Length == 1 && indexParameters[0].ParameterType == typeof(int))
				{
					value.ElementType = propertyInfo.PropertyType;
				}
			}
		}
		lock (array_metadata_lock)
		{
			try
			{
				array_metadata.Add(type, value);
			}
			catch (ArgumentException)
			{
			}
		}
	}

	private static void AddObjectMetadata(Type type)
	{
		if (object_metadata.ContainsKey(type))
		{
			return;
		}
		ObjectMetadata value = default(ObjectMetadata);
		if (type.GetInterface("System.Collections.IDictionary") != null)
		{
			value.IsDictionary = true;
		}
		value.Properties = new Dictionary<string, PropertyMetadata>();
		PropertyInfo[] properties = type.GetProperties();
		foreach (PropertyInfo propertyInfo in properties)
		{
			if (propertyInfo.Name == "Item")
			{
				ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters();
				if (indexParameters.Length == 1 && indexParameters[0].ParameterType == typeof(string))
				{
					value.ElementType = propertyInfo.PropertyType;
				}
			}
			else
			{
				PropertyMetadata value2 = default(PropertyMetadata);
				value2.Info = propertyInfo;
				value2.Type = propertyInfo.PropertyType;
				value.Properties.Add(propertyInfo.Name, value2);
			}
		}
		FieldInfo[] fields = type.GetFields();
		foreach (FieldInfo fieldInfo in fields)
		{
			PropertyMetadata value3 = default(PropertyMetadata);
			value3.Info = fieldInfo;
			value3.IsField = true;
			value3.Type = fieldInfo.FieldType;
			value.Properties.Add(fieldInfo.Name, value3);
		}
		lock (object_metadata_lock)
		{
			try
			{
				object_metadata.Add(type, value);
			}
			catch (ArgumentException)
			{
			}
		}
	}

	private static void AddTypeProperties(Type type)
	{
		if (type_properties.ContainsKey(type))
		{
			return;
		}
		IList<PropertyMetadata> list = new List<PropertyMetadata>();
		PropertyInfo[] properties = type.GetProperties();
		foreach (PropertyInfo propertyInfo in properties)
		{
			if (!(propertyInfo.Name == "Item"))
			{
				PropertyMetadata item = default(PropertyMetadata);
				item.Info = propertyInfo;
				item.IsField = false;
				list.Add(item);
			}
		}
		FieldInfo[] fields = type.GetFields();
		foreach (FieldInfo info in fields)
		{
			PropertyMetadata item2 = default(PropertyMetadata);
			item2.Info = info;
			item2.IsField = true;
			list.Add(item2);
		}
		lock (type_properties_lock)
		{
			try
			{
				type_properties.Add(type, list);
			}
			catch (ArgumentException)
			{
			}
		}
	}

	private static MethodInfo GetConvOp(Type t1, Type t2)
	{
		lock (conv_ops_lock)
		{
			if (!conv_ops.ContainsKey(t1))
			{
				conv_ops.Add(t1, new Dictionary<Type, MethodInfo>());
			}
		}
		if (conv_ops[t1].ContainsKey(t2))
		{
			return conv_ops[t1][t2];
		}
		MethodInfo method = t1.GetMethod("op_Implicit", new Type[1] { t2 });
		lock (conv_ops_lock)
		{
			try
			{
				conv_ops[t1].Add(t2, method);
				return method;
			}
			catch (ArgumentException)
			{
				return conv_ops[t1][t2];
			}
		}
	}

	private static object ReadValue(Type inst_type, JsonReader reader)
	{
		reader.Read();
		if (reader.Token == JsonToken.ArrayEnd)
		{
			return null;
		}
		Type underlyingType = Nullable.GetUnderlyingType(inst_type);
		Type type = underlyingType ?? inst_type;
		if (reader.Token == JsonToken.Null)
		{
			if (inst_type.IsClass || underlyingType != null)
			{
				return null;
			}
			throw new JsonException($"Can't assign null to an instance of type {inst_type}");
		}
		if (reader.Token == JsonToken.Double || reader.Token == JsonToken.Int || reader.Token == JsonToken.Long || reader.Token == JsonToken.String || reader.Token == JsonToken.Boolean)
		{
			Type type2 = reader.Value.GetType();
			if (type.IsAssignableFrom(type2))
			{
				return reader.Value;
			}
			if (custom_importers_table.ContainsKey(type2) && custom_importers_table[type2].ContainsKey(type))
			{
				return custom_importers_table[type2][type](reader.Value);
			}
			if (base_importers_table.ContainsKey(type2) && base_importers_table[type2].ContainsKey(type))
			{
				return base_importers_table[type2][type](reader.Value);
			}
			if (type.IsEnum)
			{
				return Enum.ToObject(type, reader.Value);
			}
			MethodInfo convOp = GetConvOp(type, type2);
			if (convOp != null)
			{
				return convOp.Invoke(null, new object[1] { reader.Value });
			}
			throw new JsonException($"Can't assign value '{reader.Value}' (type {type2}) to type {inst_type}");
		}
		object obj = null;
		if (reader.Token == JsonToken.ArrayStart)
		{
			AddArrayMetadata(inst_type);
			ArrayMetadata arrayMetadata = array_metadata[inst_type];
			if (!arrayMetadata.IsArray && !arrayMetadata.IsList)
			{
				throw new JsonException($"Type {inst_type} can't act as an array");
			}
			IList list;
			Type elementType;
			if (!arrayMetadata.IsArray)
			{
				list = (IList)Activator.CreateInstance(inst_type);
				elementType = arrayMetadata.ElementType;
			}
			else
			{
				list = new ArrayList();
				elementType = inst_type.GetElementType();
			}
			while (true)
			{
				object obj2 = ReadValue(elementType, reader);
				if (obj2 == null && reader.Token == JsonToken.ArrayEnd)
				{
					break;
				}
				list.Add(obj2);
			}
			if (arrayMetadata.IsArray)
			{
				int count = list.Count;
				obj = Array.CreateInstance(elementType, count);
				for (int i = 0; i < count; i++)
				{
					((Array)obj).SetValue(list[i], i);
				}
			}
			else
			{
				obj = list;
			}
		}
		else if (reader.Token == JsonToken.ObjectStart)
		{
			AddObjectMetadata(type);
			ObjectMetadata objectMetadata = object_metadata[type];
			obj = Activator.CreateInstance(type);
			while (true)
			{
				reader.Read();
				if (reader.Token == JsonToken.ObjectEnd)
				{
					break;
				}
				string text = (string)reader.Value;
				if (objectMetadata.Properties.ContainsKey(text))
				{
					PropertyMetadata propertyMetadata = objectMetadata.Properties[text];
					if (propertyMetadata.IsField)
					{
						((FieldInfo)propertyMetadata.Info).SetValue(obj, ReadValue(propertyMetadata.Type, reader));
						continue;
					}
					PropertyInfo propertyInfo = (PropertyInfo)propertyMetadata.Info;
					if (propertyInfo.CanWrite)
					{
						propertyInfo.SetValue(obj, ReadValue(propertyMetadata.Type, reader), null);
					}
					else
					{
						ReadValue(propertyMetadata.Type, reader);
					}
				}
				else if (!objectMetadata.IsDictionary)
				{
					if (!reader.SkipNonMembers)
					{
						throw new JsonException($"The type {inst_type} doesn't have the property '{text}'");
					}
					ReadSkip(reader);
				}
				else
				{
					((IDictionary)obj).Add(text, ReadValue(objectMetadata.ElementType, reader));
				}
			}
		}
		return obj;
	}

	private static IJsonWrapper ReadValue(WrapperFactory factory, JsonReader reader)
	{
		reader.Read();
		if (reader.Token == JsonToken.ArrayEnd || reader.Token == JsonToken.Null)
		{
			return null;
		}
		IJsonWrapper jsonWrapper = factory();
		if (reader.Token == JsonToken.String)
		{
			jsonWrapper.SetString((string)reader.Value);
			return jsonWrapper;
		}
		if (reader.Token == JsonToken.Double)
		{
			jsonWrapper.SetDouble((double)reader.Value);
			return jsonWrapper;
		}
		if (reader.Token == JsonToken.Int)
		{
			jsonWrapper.SetInt((int)reader.Value);
			return jsonWrapper;
		}
		if (reader.Token == JsonToken.Long)
		{
			jsonWrapper.SetLong((long)reader.Value);
			return jsonWrapper;
		}
		if (reader.Token == JsonToken.Boolean)
		{
			jsonWrapper.SetBoolean((bool)reader.Value);
			return jsonWrapper;
		}
		if (reader.Token == JsonToken.ArrayStart)
		{
			jsonWrapper.SetJsonType(JsonType.Array);
			while (true)
			{
				IJsonWrapper jsonWrapper2 = ReadValue(factory, reader);
				if (jsonWrapper2 == null && reader.Token == JsonToken.ArrayEnd)
				{
					break;
				}
				jsonWrapper.Add(jsonWrapper2);
			}
		}
		else if (reader.Token == JsonToken.ObjectStart)
		{
			jsonWrapper.SetJsonType(JsonType.Object);
			while (true)
			{
				reader.Read();
				if (reader.Token == JsonToken.ObjectEnd)
				{
					break;
				}
				string key = (string)reader.Value;
				jsonWrapper[key] = ReadValue(factory, reader);
			}
		}
		return jsonWrapper;
	}

	private static void ReadSkip(JsonReader reader)
	{
		ToWrapper(() => new JsonMockWrapper(), reader);
	}

	private static void RegisterBaseExporters()
	{
		base_exporters_table[typeof(byte)] = delegate(object obj, JsonWriter writer)
		{
			writer.Write(Convert.ToInt32((byte)obj));
		};
		base_exporters_table[typeof(char)] = delegate(object obj, JsonWriter writer)
		{
			writer.Write(Convert.ToString((char)obj));
		};
		base_exporters_table[typeof(DateTime)] = delegate(object obj, JsonWriter writer)
		{
			writer.Write(Convert.ToString((DateTime)obj, datetime_format));
		};
		base_exporters_table[typeof(decimal)] = delegate(object obj, JsonWriter writer)
		{
			writer.Write((decimal)obj);
		};
		base_exporters_table[typeof(sbyte)] = delegate(object obj, JsonWriter writer)
		{
			writer.Write(Convert.ToInt32((sbyte)obj));
		};
		base_exporters_table[typeof(short)] = delegate(object obj, JsonWriter writer)
		{
			writer.Write(Convert.ToInt32((short)obj));
		};
		base_exporters_table[typeof(ushort)] = delegate(object obj, JsonWriter writer)
		{
			writer.Write(Convert.ToInt32((ushort)obj));
		};
		base_exporters_table[typeof(uint)] = delegate(object obj, JsonWriter writer)
		{
			writer.Write(Convert.ToUInt64((uint)obj));
		};
		base_exporters_table[typeof(ulong)] = delegate(object obj, JsonWriter writer)
		{
			writer.Write((ulong)obj);
		};
	}

	private static void RegisterBaseImporters()
	{
		ImporterFunc importer = (object input) => Convert.ToByte((int)input);
		RegisterImporter(base_importers_table, typeof(int), typeof(byte), importer);
		importer = (object input) => Convert.ToUInt64((int)input);
		RegisterImporter(base_importers_table, typeof(int), typeof(ulong), importer);
		importer = (object input) => Convert.ToSByte((int)input);
		RegisterImporter(base_importers_table, typeof(int), typeof(sbyte), importer);
		importer = (object input) => Convert.ToInt16((int)input);
		RegisterImporter(base_importers_table, typeof(int), typeof(short), importer);
		importer = (object input) => Convert.ToUInt16((int)input);
		RegisterImporter(base_importers_table, typeof(int), typeof(ushort), importer);
		importer = (object input) => Convert.ToUInt32((int)input);
		RegisterImporter(base_importers_table, typeof(int), typeof(uint), importer);
		importer = (object input) => Convert.ToSingle((int)input);
		RegisterImporter(base_importers_table, typeof(int), typeof(float), importer);
		importer = (object input) => Convert.ToDouble((int)input);
		RegisterImporter(base_importers_table, typeof(int), typeof(double), importer);
		importer = (object input) => Convert.ToDecimal((double)input);
		RegisterImporter(base_importers_table, typeof(double), typeof(decimal), importer);
		importer = (object input) => Convert.ToUInt32((long)input);
		RegisterImporter(base_importers_table, typeof(long), typeof(uint), importer);
		importer = (object input) => Convert.ToChar((string)input);
		RegisterImporter(base_importers_table, typeof(string), typeof(char), importer);
		importer = (object input) => Convert.ToDateTime((string)input, datetime_format);
		RegisterImporter(base_importers_table, typeof(string), typeof(DateTime), importer);
	}

	private static void RegisterImporter(IDictionary<Type, IDictionary<Type, ImporterFunc>> table, Type json_type, Type value_type, ImporterFunc importer)
	{
		if (!table.ContainsKey(json_type))
		{
			table.Add(json_type, new Dictionary<Type, ImporterFunc>());
		}
		table[json_type][value_type] = importer;
	}

	private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth)
	{
		if (depth > max_nesting_depth)
		{
			throw new JsonException($"Max allowed object depth reached while trying to export from type {obj.GetType()}");
		}
		if (obj == null)
		{
			writer.Write(null);
			return;
		}
		if (obj is IJsonWrapper)
		{
			if (writer_is_private)
			{
				writer.TextWriter.Write(((IJsonWrapper)obj).ToJson());
			}
			else
			{
				((IJsonWrapper)obj).ToJson(writer);
			}
			return;
		}
		if (obj is string)
		{
			writer.Write((string)obj);
			return;
		}
		if (obj is double)
		{
			writer.Write((double)obj);
			return;
		}
		if (obj is int)
		{
			writer.Write((int)obj);
			return;
		}
		if (obj is bool)
		{
			writer.Write((bool)obj);
			return;
		}
		if (obj is long)
		{
			writer.Write((long)obj);
			return;
		}
		if (obj is Array)
		{
			writer.WriteArrayStart();
			foreach (object item in (Array)obj)
			{
				WriteValue(item, writer, writer_is_private, depth + 1);
			}
			writer.WriteArrayEnd();
			return;
		}
		if (obj is IList)
		{
			writer.WriteArrayStart();
			foreach (object item2 in (IList)obj)
			{
				WriteValue(item2, writer, writer_is_private, depth + 1);
			}
			writer.WriteArrayEnd();
			return;
		}
		if (obj is IDictionary)
		{
			writer.WriteObjectStart();
			foreach (DictionaryEntry item3 in (IDictionary)obj)
			{
				writer.WritePropertyName((string)item3.Key);
				WriteValue(item3.Value, writer, writer_is_private, depth + 1);
			}
			writer.WriteObjectEnd();
			return;
		}
		Type type = obj.GetType();
		if (custom_exporters_table.ContainsKey(type))
		{
			custom_exporters_table[type](obj, writer);
			return;
		}
		if (base_exporters_table.ContainsKey(type))
		{
			base_exporters_table[type](obj, writer);
			return;
		}
		if (obj is Enum)
		{
			Type underlyingType = Enum.GetUnderlyingType(type);
			if (underlyingType == typeof(long) || underlyingType == typeof(uint) || underlyingType == typeof(ulong))
			{
				writer.Write((ulong)obj);
			}
			else
			{
				writer.Write((int)obj);
			}
			return;
		}
		AddTypeProperties(type);
		IList<PropertyMetadata> list = type_properties[type];
		writer.WriteObjectStart();
		foreach (PropertyMetadata item4 in list)
		{
			if (item4.IsField)
			{
				writer.WritePropertyName(item4.Info.Name);
				WriteValue(((FieldInfo)item4.Info).GetValue(obj), writer, writer_is_private, depth + 1);
				continue;
			}
			PropertyInfo propertyInfo = (PropertyInfo)item4.Info;
			if (propertyInfo.CanRead)
			{
				writer.WritePropertyName(item4.Info.Name);
				WriteValue(propertyInfo.GetValue(obj, null), writer, writer_is_private, depth + 1);
			}
		}
		writer.WriteObjectEnd();
	}

	public static string ToJson(object obj)
	{
		lock (static_writer_lock)
		{
			static_writer.Reset();
			WriteValue(obj, static_writer, writer_is_private: true, 0);
			return static_writer.ToString();
		}
	}

	public static void ToJson(object obj, JsonWriter writer)
	{
		WriteValue(obj, writer, writer_is_private: false, 0);
	}

	public static JsonData ToObject(JsonReader reader)
	{
		return (JsonData)ToWrapper(() => new JsonData(), reader);
	}

	public static JsonData ToObject(TextReader reader)
	{
		JsonReader reader2 = new JsonReader(reader);
		return (JsonData)ToWrapper(() => new JsonData(), reader2);
	}

	public static JsonData ToObject(string json)
	{
		return (JsonData)ToWrapper(() => new JsonData(), json);
	}

	public static T ToObject<T>(JsonReader reader)
	{
		return (T)ReadValue(typeof(T), reader);
	}

	public static T ToObject<T>(TextReader reader)
	{
		JsonReader reader2 = new JsonReader(reader);
		return (T)ReadValue(typeof(T), reader2);
	}

	public static T ToObject<T>(string json)
	{
		JsonReader reader = new JsonReader(json);
		return (T)ReadValue(typeof(T), reader);
	}

	public static object ToObject(string json, Type ConvertType)
	{
		JsonReader reader = new JsonReader(json);
		return ReadValue(ConvertType, reader);
	}

	public static IJsonWrapper ToWrapper(WrapperFactory factory, JsonReader reader)
	{
		return ReadValue(factory, reader);
	}

	public static IJsonWrapper ToWrapper(WrapperFactory factory, string json)
	{
		JsonReader reader = new JsonReader(json);
		return ReadValue(factory, reader);
	}

	public static void RegisterExporter<T>(ExporterFunc<T> exporter)
	{
		ExporterFunc value = delegate(object obj, JsonWriter writer)
		{
			exporter((T)obj, writer);
		};
		custom_exporters_table[typeof(T)] = value;
	}

	public static void RegisterImporter<TJson, TValue>(ImporterFunc<TJson, TValue> importer)
	{
		ImporterFunc importer2 = (object input) => importer((TJson)input);
		RegisterImporter(custom_importers_table, typeof(TJson), typeof(TValue), importer2);
	}

	public static void UnregisterExporters()
	{
		custom_exporters_table.Clear();
	}

	public static void UnregisterImporters()
	{
		custom_importers_table.Clear();
	}
}
public class JsonMockWrapper : IJsonWrapper, IList, ICollection, IEnumerable, IOrderedDictionary, IDictionary
{
	public bool IsArray => false;

	public bool IsBoolean => false;

	public bool IsDouble => false;

	public bool IsInt => false;

	public bool IsLong => false;

	public bool IsObject => false;

	public bool IsString => false;

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	object IList.this[int index]
	{
		get
		{
			return null;
		}
		set
		{
		}
	}

	int ICollection.Count => 0;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => null;

	bool IDictionary.IsFixedSize => true;

	bool IDictionary.IsReadOnly => true;

	ICollection IDictionary.Keys => null;

	ICollection IDictionary.Values => null;

	object IDictionary.this[object key]
	{
		get
		{
			return null;
		}
		set
		{
		}
	}

	object IOrderedDictionary.this[int idx]
	{
		get
		{
			return null;
		}
		set
		{
		}
	}

	public bool GetBoolean()
	{
		return false;
	}

	public double GetDouble()
	{
		return 0.0;
	}

	public int GetInt()
	{
		return 0;
	}

	public JsonType GetJsonType()
	{
		return JsonType.None;
	}

	public long GetLong()
	{
		return 0L;
	}

	public string GetString()
	{
		return "";
	}

	public void SetBoolean(bool val)
	{
	}

	public void SetDouble(double val)
	{
	}

	public void SetInt(int val)
	{
	}

	public void SetJsonType(JsonType type)
	{
	}

	public void SetLong(long val)
	{
	}

	public void SetString(string val)
	{
	}

	public string ToJson()
	{
		return "";
	}

	public void ToJson(JsonWriter writer)
	{
	}

	int IList.Add(object value)
	{
		return 0;
	}

	void IList.Clear()
	{
	}

	bool IList.Contains(object value)
	{
		return false;
	}

	int IList.IndexOf(object value)
	{
		return -1;
	}

	void IList.Insert(int i, object v)
	{
	}

	void IList.Remove(object value)
	{
	}

	void IList.RemoveAt(int index)
	{
	}

	void ICollection.CopyTo(Array array, int index)
	{
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return null;
	}

	void IDictionary.Add(object k, object v)
	{
	}

	void IDictionary.Clear()
	{
	}

	bool IDictionary.Contains(object key)
	{
		return false;
	}

	void IDictionary.Remove(object key)
	{
	}

	IDictionaryEnumerator IDictionary.GetEnumerator()
	{
		return null;
	}

	IDictionaryEnumerator IOrderedDictionary.GetEnumerator()
	{
		return null;
	}

	void IOrderedDictionary.Insert(int i, object k, object v)
	{
	}

	void IOrderedDictionary.RemoveAt(int i)
	{
	}
}
public enum JsonToken
{
	None,
	ObjectStart,
	PropertyName,
	ObjectEnd,
	ArrayStart,
	ArrayEnd,
	Int,
	Long,
	Double,
	String,
	Boolean,
	Null
}
public class JsonReader
{
	private static readonly IDictionary<int, IDictionary<int, int[]>> parse_table;

	private Stack<int> automaton_stack;

	private int current_input;

	private int current_symbol;

	private bool end_of_json;

	private bool end_of_input;

	private Lexer lexer;

	private bool parser_in_string;

	private bool parser_return;

	private bool read_started;

	private TextReader reader;

	private bool reader_is_owned;

	private bool skip_non_members;

	private object token_value;

	private JsonToken token;

	public bool AllowComments
	{
		get
		{
			return lexer.AllowComments;
		}
		set
		{
			lexer.AllowComments = value;
		}
	}

	public bool AllowSingleQuotedStrings
	{
		get
		{
			return lexer.AllowSingleQuotedStrings;
		}
		set
		{
			lexer.AllowSingleQuotedStrings = value;
		}
	}

	public bool SkipNonMembers
	{
		get
		{
			return skip_non_members;
		}
		set
		{
			skip_non_members = value;
		}
	}

	public bool EndOfInput => end_of_input;

	public bool EndOfJson => end_of_json;

	public JsonToken Token => token;

	public object Value => token_value;

	static JsonReader()
	{
		parse_table = PopulateParseTable();
	}

	public JsonReader(string json_text)
		: this(new StringReader(json_text), owned: true)
	{
	}

	public JsonReader(TextReader reader)
		: this(reader, owned: false)
	{
	}

	private JsonReader(TextReader reader, bool owned)
	{
		if (reader == null)
		{
			throw new ArgumentNullException("reader");
		}
		parser_in_string = false;
		parser_return = false;
		read_started = false;
		automaton_stack = new Stack<int>();
		automaton_stack.Push(65553);
		automaton_stack.Push(65543);
		lexer = new Lexer(reader);
		end_of_input = false;
		end_of_json = false;
		skip_non_members = true;
		this.reader = reader;
		reader_is_owned = owned;
	}

	private static IDictionary<int, IDictionary<int, int[]>> PopulateParseTable()
	{
		IDictionary<int, IDictionary<int, int[]>> result = new Dictionary<int, IDictionary<int, int[]>>();
		TableAddRow(result, ParserToken.Array);
		TableAddCol(result, ParserToken.Array, 91, 91, 65549);
		TableAddRow(result, ParserToken.ArrayPrime);
		TableAddCol(result, ParserToken.ArrayPrime, 34, 65550, 65551, 93);
		TableAddCol(result, ParserToken.ArrayPrime, 91, 65550, 65551, 93);
		TableAddCol(result, ParserToken.ArrayPrime, 93, 93);
		TableAddCol(result, ParserToken.ArrayPrime, 123, 65550, 65551, 93);
		TableAddCol(result, ParserToken.ArrayPrime, 65537, 65550, 65551, 93);
		TableAddCol(result, ParserToken.ArrayPrime, 65538, 65550, 65551, 93);
		TableAddCol(result, ParserToken.ArrayPrime, 65539, 65550, 65551, 93);
		TableAddCol(result, ParserToken.ArrayPrime, 65540, 65550, 65551, 93);
		TableAddRow(result, ParserToken.Object);
		TableAddCol(result, ParserToken.Object, 123, 123, 65545);
		TableAddRow(result, ParserToken.ObjectPrime);
		TableAddCol(result, ParserToken.ObjectPrime, 34, 65546, 65547, 125);
		TableAddCol(result, ParserToken.ObjectPrime, 125, 125);
		TableAddRow(result, ParserToken.Pair);
		TableAddCol(result, ParserToken.Pair, 34, 65552, 58, 65550);
		TableAddRow(result, ParserToken.PairRest);
		TableAddCol(result, ParserToken.PairRest, 44, 44, 65546, 65547);
		TableAddCol(result, ParserToken.PairRest, 125, 65554);
		TableAddRow(result, ParserToken.String);
		TableAddCol(result, ParserToken.String, 34, 34, 65541, 34);
		TableAddRow(result, ParserToken.Text);
		TableAddCol(result, ParserToken.Text, 91, 65548);
		TableAddCol(result, ParserToken.Text, 123, 65544);
		TableAddRow(result, ParserToken.Value);
		TableAddCol(result, ParserToken.Value, 34, 65552);
		TableAddCol(result, ParserToken.Value, 91, 65548);
		TableAddCol(result, ParserToken.Value, 123, 65544);
		TableAddCol(result, ParserToken.Value, 65537, 65537);
		TableAddCol(result, ParserToken.Value, 65538, 65538);
		TableAddCol(result, ParserToken.Value, 65539, 65539);
		TableAddCol(result, ParserToken.Value, 65540, 65540);
		TableAddRow(result, ParserToken.ValueRest);
		TableAddCol(result, ParserToken.ValueRest, 44, 44, 65550, 65551);
		TableAddCol(result, ParserToken.ValueRest, 93, 65554);
		return result;
	}

	private static void TableAddCol(IDictionary<int, IDictionary<int, int[]>> parse_table, ParserToken row, int col, params int[] symbols)
	{
		parse_table[(int)row].Add(col, symbols);
	}

	private static void TableAddRow(IDictionary<int, IDictionary<int, int[]>> parse_table, ParserToken rule)
	{
		parse_table.Add((int)rule, new Dictionary<int, int[]>());
	}

	private void ProcessNumber(string number)
	{
		int result2;
		long result3;
		ulong result4;
		if ((number.IndexOf('.') != -1 || number.IndexOf('e') != -1 || number.IndexOf('E') != -1) && double.TryParse(number, NumberStyles.Any, CultureInfo.InvariantCulture, out var result))
		{
			token = JsonToken.Double;
			token_value = result;
		}
		else if (int.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out result2))
		{
			token = JsonToken.Int;
			token_value = result2;
		}
		else if (long.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out result3))
		{
			token = JsonToken.Long;
			token_value = result3;
		}
		else if (ulong.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out result4))
		{
			token = JsonToken.Long;
			token_value = result4;
		}
		else
		{
			token = JsonToken.Int;
			token_value = 0;
		}
	}

	private void ProcessSymbol()
	{
		if (current_symbol == 91)
		{
			token = JsonToken.ArrayStart;
			parser_return = true;
		}
		else if (current_symbol == 93)
		{
			token = JsonToken.ArrayEnd;
			parser_return = true;
		}
		else if (current_symbol == 123)
		{
			token = JsonToken.ObjectStart;
			parser_return = true;
		}
		else if (current_symbol == 125)
		{
			token = JsonToken.ObjectEnd;
			parser_return = true;
		}
		else if (current_symbol == 34)
		{
			if (parser_in_string)
			{
				parser_in_string = false;
				parser_return = true;
				return;
			}
			if (token == JsonToken.None)
			{
				token = JsonToken.String;
			}
			parser_in_string = true;
		}
		else if (current_symbol == 65541)
		{
			token_value = lexer.StringValue;
		}
		else if (current_symbol == 65539)
		{
			token = JsonToken.Boolean;
			token_value = false;
			parser_return = true;
		}
		else if (current_symbol == 65540)
		{
			token = JsonToken.Null;
			parser_return = true;
		}
		else if (current_symbol == 65537)
		{
			ProcessNumber(lexer.StringValue);
			parser_return = true;
		}
		else if (current_symbol == 65546)
		{
			token = JsonToken.PropertyName;
		}
		else if (current_symbol == 65538)
		{
			token = JsonToken.Boolean;
			token_value = true;
			parser_return = true;
		}
	}

	private bool ReadToken()
	{
		if (end_of_input)
		{
			return false;
		}
		lexer.NextToken();
		if (lexer.EndOfInput)
		{
			Close();
			return false;
		}
		current_input = lexer.Token;
		return true;
	}

	public void Close()
	{
		if (end_of_input)
		{
			return;
		}
		end_of_input = true;
		end_of_json = true;
		if (reader_is_owned)
		{
			using (reader)
			{
			}
		}
		reader = null;
	}

	public bool Read()
	{
		if (end_of_input)
		{
			return false;
		}
		if (end_of_json)
		{
			end_of_json = false;
			automaton_stack.Clear();
			automaton_stack.Push(65553);
			automaton_stack.Push(65543);
		}
		parser_in_string = false;
		parser_return = false;
		token = JsonToken.None;
		token_value = null;
		if (!read_started)
		{
			read_started = true;
			if (!ReadToken())
			{
				return false;
			}
		}
		while (true)
		{
			if (parser_return)
			{
				if (automaton_stack.Peek() == 65553)
				{
					end_of_json = true;
				}
				return true;
			}
			current_symbol = automaton_stack.Pop();
			ProcessSymbol();
			if (current_symbol == current_input)
			{
				if (!ReadToken())
				{
					break;
				}
				continue;
			}
			int[] array;
			try
			{
				array = parse_table[current_symbol][current_input];
			}
			catch (KeyNotFoundException inner_exception)
			{
				throw new JsonException((ParserToken)current_input, inner_exception);
			}
			if (array[0] != 65554)
			{
				for (int num = array.Length - 1; num >= 0; num--)
				{
					automaton_stack.Push(array[num]);
				}
			}
		}
		if (automaton_stack.Peek() != 65553)
		{
			throw new JsonException("Input doesn't evaluate to proper JSON text");
		}
		if (parser_return)
		{
			return true;
		}
		return false;
	}
}
internal enum Condition
{
	InArray,
	InObject,
	NotAProperty,
	Property,
	Value
}
internal class WriterContext
{
	public int Count;

	public bool InArray;

	public bool InObject;

	public bool ExpectingValue;

	public int Padding;
}
public class JsonWriter
{
	private static readonly NumberFormatInfo number_format;

	private WriterContext context;

	private Stack<WriterContext> ctx_stack;

	private bool has_reached_end;

	private char[] hex_seq;

	private int indentation;

	private int indent_value;

	private StringBuilder inst_string_builder;

	private bool pretty_print;

	private bool validate;

	private bool lower_case_properties;

	private TextWriter writer;

	public int IndentValue
	{
		get
		{
			return indent_value;
		}
		set
		{
			indentation = indentation / indent_value * value;
			indent_value = value;
		}
	}

	public bool PrettyPrint
	{
		get
		{
			return pretty_print;
		}
		set
		{
			pretty_print = value;
		}
	}

	public TextWriter TextWriter => writer;

	public bool Validate
	{
		get
		{
			return validate;
		}
		set
		{
			validate = value;
		}
	}

	public bool LowerCaseProperties
	{
		get
		{
			return lower_case_properties;
		}
		set
		{
			lower_case_properties = value;
		}
	}

	static JsonWriter()
	{
		number_format = NumberFormatInfo.InvariantInfo;
	}

	public JsonWriter()
	{
		inst_string_builder = new StringBuilder();
		writer = new StringWriter(inst_string_builder);
		Init();
	}

	public JsonWriter(StringBuilder sb)
		: this(new StringWriter(sb))
	{
	}

	public JsonWriter(TextWriter writer)
	{
		if (writer == null)
		{
			throw new ArgumentNullException("writer");
		}
		this.writer = writer;
		Init();
	}

	private void DoValidation(Condition cond)
	{
		if (!context.ExpectingValue)
		{
			context.Count++;
		}
		if (!validate)
		{
			return;
		}
		if (has_reached_end)
		{
			throw new JsonException("A complete JSON symbol has already been written");
		}
		switch (cond)
		{
		case Condition.InArray:
			if (!context.InArray)
			{
				throw new JsonException("Can't close an array here");
			}
			break;
		case Condition.InObject:
			if (!context.InObject || context.ExpectingValue)
			{
				throw new JsonException("Can't close an object here");
			}
			break;
		case Condition.NotAProperty:
			if (context.InObject && !context.ExpectingValue)
			{
				throw new JsonException("Expected a property");
			}
			break;
		case Condition.Property:
			if (!context.InObject || context.ExpectingValue)
			{
				throw new JsonException("Can't add a property here");
			}
			break;
		case Condition.Value:
			if (!context.InArray && (!context.InObject || !context.ExpectingValue))
			{
				throw new JsonException("Can't add a value here");
			}
			break;
		}
	}

	private void Init()
	{
		has_reached_end = false;
		hex_seq = new char[4];
		indentation = 0;
		indent_value = 4;
		pretty_print = false;
		validate = true;
		lower_case_properties = false;
		ctx_stack = new Stack<WriterContext>();
		context = new WriterContext();
		ctx_stack.Push(context);
	}

	private static void IntToHex(int n, char[] hex)
	{
		for (int i = 0; i < 4; i++)
		{
			int num = n % 16;
			if (num < 10)
			{
				hex[3 - i] = (char)(48 + num);
			}
			else
			{
				hex[3 - i] = (char)(65 + (num - 10));
			}
			n >>= 4;
		}
	}

	private void Indent()
	{
		if (pretty_print)
		{
			indentation += indent_value;
		}
	}

	private void Put(string str)
	{
		if (pretty_print && !context.ExpectingValue)
		{
			for (int i = 0; i < indentation; i++)
			{
				writer.Write(' ');
			}
		}
		writer.Write(str);
	}

	private void PutNewline()
	{
		PutNewline(add_comma: true);
	}

	private void PutNewline(bool add_comma)
	{
		if (add_comma && !context.ExpectingValue && context.Count > 1)
		{
			writer.Write(',');
		}
		if (pretty_print && !context.ExpectingValue)
		{
			writer.Write('\n');
		}
	}

	private void PutString(string str)
	{
		Put(string.Empty);
		writer.Write('"');
		int length = str.Length;
		for (int i = 0; i < length; i++)
		{
			switch (str[i])
			{
			case '\n':
				writer.Write("\\n");
				continue;
			case '\r':
				writer.Write("\\r");
				continue;
			case '\t':
				writer.Write("\\t");
				continue;
			case '"':
			case '\\':
				writer.Write('\\');
				writer.Write(str[i]);
				continue;
			case '\f':
				writer.Write("\\f");
				continue;
			case '\b':
				writer.Write("\\b");
				continue;
			}
			if (str[i] >= ' ' && str[i] <= '~')
			{
				writer.Write(str[i]);
				continue;
			}
			IntToHex(str[i], hex_seq);
			writer.Write("\\u");
			writer.Write(hex_seq);
		}
		writer.Write('"');
	}

	private void Unindent()
	{
		if (pretty_print)
		{
			indentation -= indent_value;
		}
	}

	public override string ToString()
	{
		if (inst_string_builder == null)
		{
			return string.Empty;
		}
		return inst_string_builder.ToString();
	}

	public void Reset()
	{
		has_reached_end = false;
		ctx_stack.Clear();
		context = new WriterContext();
		ctx_stack.Push(context);
		if (inst_string_builder != null)
		{
			inst_string_builder.Remove(0, inst_string_builder.Length);
		}
	}

	public void Write(bool boolean)
	{
		DoValidation(Condition.Value);
		PutNewline();
		Put(boolean ? "true" : "false");
		context.ExpectingValue = false;
	}

	public void Write(decimal number)
	{
		DoValidation(Condition.Value);
		PutNewline();
		Put(Convert.ToString(number, number_format));
		context.ExpectingValue = false;
	}

	public void Write(double number)
	{
		DoValidation(Condition.Value);
		PutNewline();
		string text = Convert.ToString(number, number_format);
		Put(text);
		if (text.IndexOf('.') == -1 && text.IndexOf('E') == -1)
		{
			writer.Write(".0");
		}
		context.ExpectingValue = false;
	}

	public void Write(int number)
	{
		DoValidation(Condition.Value);
		PutNewline();
		Put(Convert.ToString(number, number_format));
		context.ExpectingValue = false;
	}

	public void Write(long number)
	{
		DoValidation(Condition.Value);
		PutNewline();
		Put(Convert.ToString(number, number_format));
		context.ExpectingValue = false;
	}

	public void Write(string str)
	{
		DoValidation(Condition.Value);
		PutNewline();
		if (str == null)
		{
			Put("null");
		}
		else
		{
			PutString(str);
		}
		context.ExpectingValue = false;
	}

	[CLSCompliant(false)]
	public void Write(ulong number)
	{
		DoValidation(Condition.Value);
		PutNewline();
		Put(Convert.ToString(number, number_format));
		context.ExpectingValue = false;
	}

	public void WriteArrayEnd()
	{
		DoValidation(Condition.InArray);
		PutNewline(add_comma: false);
		ctx_stack.Pop();
		if (ctx_stack.Count == 1)
		{
			has_reached_end = true;
		}
		else
		{
			context = ctx_stack.Peek();
			context.ExpectingValue = false;
		}
		Unindent();
		Put("]");
	}

	public void WriteArrayStart()
	{
		DoValidation(Condition.NotAProperty);
		PutNewline();
		Put("[");
		context = new WriterContext();
		context.InArray = true;
		ctx_stack.Push(context);
		Indent();
	}

	public void WriteObjectEnd()
	{
		DoValidation(Condition.InObject);
		PutNewline(add_comma: false);
		ctx_stack.Pop();
		if (ctx_stack.Count == 1)
		{
			has_reached_end = true;
		}
		else
		{
			context = ctx_stack.Peek();
			context.ExpectingValue = false;
		}
		Unindent();
		Put("}");
	}

	public void WriteObjectStart()
	{
		DoValidation(Condition.NotAProperty);
		PutNewline();
		Put("{");
		context = new WriterContext();
		context.InObject = true;
		ctx_stack.Push(context);
		Indent();
	}

	public void WritePropertyName(string property_name)
	{
		DoValidation(Condition.Property);
		PutNewline();
		string text = ((property_name == null || !lower_case_properties) ? property_name : property_name.ToLowerInvariant());
		PutString(text);
		if (pretty_print)
		{
			if (text.Length > context.Padding)
			{
				context.Padding = text.Length;
			}
			for (int num = context.Padding - text.Length; num >= 0; num--)
			{
				writer.Write(' ');
			}
			writer.Write(": ");
		}
		else
		{
			writer.Write(':');
		}
		context.ExpectingValue = true;
	}
}
internal class FsmContext
{
	public bool Return;

	public int NextState;

	public Lexer L;

	public int StateStack;
}
internal class Lexer
{
	private delegate bool StateHandler(FsmContext ctx);

	private static readonly int[] fsm_return_table;

	private static readonly StateHandler[] fsm_handler_table;

	private bool allow_comments;

	private bool allow_single_quoted_strings;

	private bool end_of_input;

	private FsmContext fsm_context;

	private int input_buffer;

	private int input_char;

	private TextReader reader;

	private int state;

	private StringBuilder string_buffer;

	private string string_value;

	private int token;

	private int unichar;

	public bool AllowComments
	{
		get
		{
			return allow_comments;
		}
		set
		{
			allow_comments = value;
		}
	}

	public bool AllowSingleQuotedStrings
	{
		get
		{
			return allow_single_quoted_strings;
		}
		set
		{
			allow_single_quoted_strings = value;
		}
	}

	public bool EndOfInput => end_of_input;

	public int Token => token;

	public string StringValue => string_value;

	static Lexer()
	{
		PopulateFsmTables(out fsm_handler_table, out fsm_return_table);
	}

	public Lexer(TextReader reader)
	{
		allow_comments = true;
		allow_single_quoted_strings = true;
		input_buffer = 0;
		string_buffer = new StringBuilder(128);
		state = 1;
		end_of_input = false;
		this.reader = reader;
		fsm_context = new FsmContext();
		fsm_context.L = this;
	}

	private static int HexValue(int digit)
	{
		switch (digit)
		{
		case 65:
		case 97:
			return 10;
		case 66:
		case 98:
			return 11;
		case 67:
		case 99:
			return 12;
		case 68:
		case 100:
			return 13;
		case 69:
		case 101:
			return 14;
		case 70:
		case 102:
			return 15;
		default:
			return digit - 48;
		}
	}

	private static void PopulateFsmTables(out StateHandler[] fsm_handler_table, out int[] fsm_return_table)
	{
		fsm_handler_table = new StateHandler[28]
		{
			State1, State2, State3, State4, State5, State6, State7, State8, State9, State10,
			State11, State12, State13, State14, State15, State16, State17, State18, State19, State20,
			State21, State22, State23, State24, State25, State26, State27, State28
		};
		fsm_return_table = new int[28]
		{
			65542, 0, 65537, 65537, 0, 65537, 0, 65537, 0, 0,
			65538, 0, 0, 0, 65539, 0, 0, 65540, 65541, 65542,
			0, 0, 65541, 65542, 0, 0, 0, 0
		};
	}

	private static char ProcessEscChar(int esc_char)
	{
		switch (esc_char)
		{
		case 34:
		case 39:
		case 47:
		case 92:
			return Convert.ToChar(esc_char);
		case 110:
			return '\n';
		case 116:
			return '\t';
		case 114:
			return '\r';
		case 98:
			return '\b';
		case 102:
			return '\f';
		default:
			return '?';
		}
	}

	private static bool State1(FsmContext ctx)
	{
		while (ctx.L.GetChar())
		{
			if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
			{
				continue;
			}
			if (ctx.L.input_char >= 49 && ctx.L.input_char <= 57)
			{
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				ctx.NextState = 3;
				return true;
			}
			switch (ctx.L.input_char)
			{
			case 34:
				ctx.NextState = 19;
				ctx.Return = true;
				return true;
			case 44:
			case 58:
			case 91:
			case 93:
			case 123:
			case 125:
				ctx.NextState = 1;
				ctx.Return = true;
				return true;
			case 45:
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				ctx.NextState = 2;
				return true;
			case 48:
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				ctx.NextState = 4;
				return true;
			case 102:
				ctx.NextState = 12;
				return true;
			case 110:
				ctx.NextState = 16;
				return true;
			case 116:
				ctx.NextState = 9;
				return true;
			case 39:
				if (!ctx.L.allow_single_quoted_strings)
				{
					return false;
				}
				ctx.L.input_char = 34;
				ctx.NextState = 23;
				ctx.Return = true;
				return true;
			case 47:
				if (!ctx.L.allow_comments)
				{
					return false;
				}
				ctx.NextState = 25;
				return true;
			default:
				return false;
			}
		}
		return true;
	}

	private static bool State2(FsmContext ctx)
	{
		ctx.L.GetChar();
		if (ctx.L.input_char >= 49 && ctx.L.input_char <= 57)
		{
			ctx.L.string_buffer.Append((char)ctx.L.input_char);
			ctx.NextState = 3;
			return true;
		}
		int num = ctx.L.input_char;
		if (num == 48)
		{
			ctx.L.string_buffer.Append((char)ctx.L.input_char);
			ctx.NextState = 4;
			return true;
		}
		return false;
	}

	private static bool State3(FsmContext ctx)
	{
		while (ctx.L.GetChar())
		{
			if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
			{
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				continue;
			}
			if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
			{
				ctx.Return = true;
				ctx.NextState = 1;
				return true;
			}
			switch (ctx.L.input_char)
			{
			case 44:
			case 93:
			case 125:
				ctx.L.UngetChar();
				ctx.Return = true;
				ctx.NextState = 1;
				return true;
			case 46:
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				ctx.NextState = 5;
				return true;
			case 69:
			case 101:
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				ctx.NextState = 7;
				return true;
			default:
				return false;
			}
		}
		return true;
	}

	private static bool State4(FsmContext ctx)
	{
		ctx.L.GetChar();
		if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
		{
			ctx.Return = true;
			ctx.NextState = 1;
			return true;
		}
		switch (ctx.L.input_char)
		{
		case 44:
		case 93:
		case 125:
			ctx.L.UngetChar();
			ctx.Return = true;
			ctx.NextState = 1;
			return true;
		case 46:
			ctx.L.string_buffer.Append((char)ctx.L.input_char);
			ctx.NextState = 5;
			return true;
		case 69:
		case 101:
			ctx.L.string_buffer.Append((char)ctx.L.input_char);
			ctx.NextState = 7;
			return true;
		default:
			return false;
		}
	}

	private static bool State5(FsmContext ctx)
	{
		ctx.L.GetChar();
		if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
		{
			ctx.L.string_buffer.Append((char)ctx.L.input_char);
			ctx.NextState = 6;
			return true;
		}
		return false;
	}

	private static bool State6(FsmContext ctx)
	{
		while (ctx.L.GetChar())
		{
			if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
			{
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				continue;
			}
			if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
			{
				ctx.Return = true;
				ctx.NextState = 1;
				return true;
			}
			switch (ctx.L.input_char)
			{
			case 44:
			case 93:
			case 125:
				ctx.L.UngetChar();
				ctx.Return = true;
				ctx.NextState = 1;
				return true;
			case 69:
			case 101:
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				ctx.NextState = 7;
				return true;
			default:
				return false;
			}
		}
		return true;
	}

	private static bool State7(FsmContext ctx)
	{
		ctx.L.GetChar();
		if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
		{
			ctx.L.string_buffer.Append((char)ctx.L.input_char);
			ctx.NextState = 8;
			return true;
		}
		int num = ctx.L.input_char;
		if (num == 43 || num == 45)
		{
			ctx.L.string_buffer.Append((char)ctx.L.input_char);
			ctx.NextState = 8;
			return true;
		}
		return false;
	}

	private static bool State8(FsmContext ctx)
	{
		while (ctx.L.GetChar())
		{
			if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
			{
				ctx.L.string_buffer.Append((char)ctx.L.input_char);
				continue;
			}
			if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
			{
				ctx.Return = true;
				ctx.NextState = 1;
				return true;
			}
			int num = ctx.L.input_char;
			if (num == 44 || num == 93 || num == 125)
			{
				ctx.L.UngetChar();
				ctx.Return = true;
				ctx.NextState = 1;
				return true;
			}
			return false;
		}
		return true;
	}

	private static bool State9(FsmContext ctx)
	{
		ctx.L.GetChar();
		int num = ctx.L.input_char;
		if (num == 114)
		{
			ctx.NextState = 10;
			return true;
		}
		return false;
	}

	private static bool State10(FsmContext ctx)
	{
		ctx.L.GetChar();
		int num = ctx.L.input_char;
		if (num == 117)
		{
			ctx.NextState = 11;
			return true;
		}
		return false;
	}

	private static bool State11(FsmContext ctx)
	{
		ctx.L.GetChar();
		int num = ctx.L.input_char;
		if (num == 101)
		{
			ctx.Return = true;
			ctx.NextState = 1;
			return true;
		}
		return false;
	}

	private static bool State12(FsmContext ctx)
	{
		ctx.L.GetChar();
		int num = ctx.L.input_char;
		if (num == 97)
		{
			ctx.NextState = 13;
			return true;
		}
		return false;
	}

	private static bool State13(FsmContext ctx)
	{
		ctx.L.GetChar();
		int num = ctx.L.input_char;
		if (num == 108)
		{
			ctx.NextState = 14;
			return true;
		}
		return false;
	}

	private static bool State14(FsmContext ctx)
	{
		ctx.L.GetChar();
		int num = ctx.L.input_char;
		if (num == 115)
		{
			ctx.NextState = 15;
			return true;
		}
		return false;
	}

	private static bool State15(FsmContext ctx)
	{
		ctx.L.GetChar();
		int num = ctx.L.input_char;
		if (num == 101)
		{
			ctx.Return = true;
			ctx.NextState = 1;
			return true;
		}
		return false;
	}

	private static bool State16(FsmContext ctx)
	{
		ctx.L.GetChar();
		int num = ctx.L.input_char;
		if (num == 117)
		{
			ctx.NextState = 17;
			return true;
		}
		return false;
	}

	private static bool State17(FsmContext ctx)
	{
		ctx.L.GetChar();
		int num = ctx.L.input_char;
		if (num == 108)
		{
			ctx.NextState = 18;
			return true;
		}
		return false;
	}

	private static bool State18(FsmContext ctx)
	{
		ctx.L.GetChar();
		int num = ctx.L.input_char;
		if (num == 108)
		{
			ctx.Return = true;
			ctx.NextState = 1;
			return true;
		}
		return false;
	}

	private static bool State19(FsmContext ctx)
	{
		while (ctx.L.GetChar())
		{
			switch (ctx.L.input_char)
			{
			case 34:
				ctx.L.UngetChar();
				ctx.Return = true;
				ctx.NextState = 20;
				return true;
			case 92:
				ctx.StateStack = 19;
				ctx.NextState = 21;
				return true;
			}
			ctx.L.string_buffer.Append((char)ctx.L.input_char);
		}
		return true;
	}

	private static bool State20(FsmContext ctx)
	{
		ctx.L.GetChar();
		int num = ctx.L.input_char;
		if (num == 34)
		{
			ctx.Return = true;
			ctx.NextState = 1;
			return true;
		}
		return false;
	}

	private static bool State21(FsmContext ctx)
	{
		ctx.L.GetChar();
		switch (ctx.L.input_char)
		{
		case 117:
			ctx.NextState = 22;
			return true;
		case 34:
		case 39:
		case 47:
		case 92:
		case 98:
		case 102:
		case 110:
		case 114:
		case 116:
			ctx.L.string_buffer.Append(ProcessEscChar(ctx.L.input_char));
			ctx.NextState = ctx.StateStack;
			return true;
		default:
			return false;
		}
	}

	private static bool State22(FsmContext ctx)
	{
		int num = 0;
		int num2 = 4096;
		ctx.L.unichar = 0;
		while (ctx.L.GetChar())
		{
			if ((ctx.L.input_char >= 48 && ctx.L.input_char <= 57) || (ctx.L.input_char >= 65 && ctx.L.input_char <= 70) || (ctx.L.input_char >= 97 && ctx.L.input_char <= 102))
			{
				ctx.L.unichar += HexValue(ctx.L.input_char) * num2;
				num++;
				num2 /= 16;
				if (num == 4)
				{
					ctx.L.string_buffer.Append(Convert.ToChar(ctx.L.unichar));
					ctx.NextState = ctx.StateStack;
					return true;
				}
				continue;
			}
			return false;
		}
		return true;
	}

	private static bool State23(FsmContext ctx)
	{
		while (ctx.L.GetChar())
		{
			switch (ctx.L.input_char)
			{
			case 39:
				ctx.L.UngetChar();
				ctx.Return = true;
				ctx.NextState = 24;
				return true;
			case 92:
				ctx.StateStack = 23;
				ctx.NextState = 21;
				return true;
			}
			ctx.L.string_buffer.Append((char)ctx.L.input_char);
		}
		return true;
	}

	private static bool State24(FsmContext ctx)
	{
		ctx.L.GetChar();
		int num = ctx.L.input_char;
		if (num == 39)
		{
			ctx.L.input_char = 34;
			ctx.Return = true;
			ctx.NextState = 1;
			return true;
		}
		return false;
	}

	private static bool State25(FsmContext ctx)
	{
		ctx.L.GetChar();
		switch (ctx.L.input_char)
		{
		case 42:
			ctx.NextState = 27;
			return true;
		case 47:
			ctx.NextState = 26;
			return true;
		default:
			return false;
		}
	}

	private static bool State26(FsmContext ctx)
	{
		while (ctx.L.GetChar())
		{
			if (ctx.L.input_char == 10)
			{
				ctx.NextState = 1;
				return true;
			}
		}
		return true;
	}

	private static bool State27(FsmContext ctx)
	{
		while (ctx.L.GetChar())
		{
			if (ctx.L.input_char == 42)
			{
				ctx.NextState = 28;
				return true;
			}
		}
		return true;
	}

	private static bool State28(FsmContext ctx)
	{
		while (ctx.L.GetChar())
		{
			if (ctx.L.input_char != 42)
			{
				if (ctx.L.input_char == 47)
				{
					ctx.NextState = 1;
					return true;
				}
				ctx.NextState = 27;
				return true;
			}
		}
		return true;
	}

	private bool GetChar()
	{
		if ((input_char = NextChar()) != -1)
		{
			return true;
		}
		end_of_input = true;
		return false;
	}

	private int NextChar()
	{
		if (input_buffer != 0)
		{
			int result = input_buffer;
			input_buffer = 0;
			return result;
		}
		return reader.Read();
	}

	public bool NextToken()
	{
		fsm_context.Return = false;
		while (true)
		{
			if (!fsm_handler_table[state - 1](fsm_context))
			{
				throw new JsonException(input_char);
			}
			if (end_of_input)
			{
				return false;
			}
			if (fsm_context.Return)
			{
				break;
			}
			state = fsm_context.NextState;
		}
		string_value = string_buffer.ToString();
		string_buffer.Remove(0, string_buffer.Length);
		token = fsm_return_table[state - 1];
		if (token == 65542)
		{
			token = input_char;
		}
		state = fsm_context.NextState;
		return true;
	}

	private void UngetChar()
	{
		input_buffer = input_char;
	}
}
internal enum ParserToken
{
	None = 65536,
	Number,
	True,
	False,
	Null,
	CharSeq,
	Char,
	Text,
	Object,
	ObjectPrime,
	Pair,
	PairRest,
	Array,
	ArrayPrime,
	Value,
	ValueRest,
	String,
	End,
	Epsilon
}