Decompiled source of Grey Announcer v1.1.1

Newtonsoft.Json.dll

Decompiled a month ago
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Data;
using System.Data.SqlTypes;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Numerics;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Linq;
using Microsoft.CodeAnalysis;
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;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AllowPartiallyTrustedCallers]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Schema, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f561df277c6c0b497d629032b410cdcf286e537c054724f7ffa0164345f62b3e642029d7a80cc351918955328c4adc8a048823ef90b0cf38ea7db0d729caf2b633c3babe08b0310198c1081995c19029bc675193744eab9d7345b8a67258ec17d112cebdbbb2a281487dceeafb9d83aa930f32103fbe1d2911425bc5744002c7")]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f561df277c6c0b497d629032b410cdcf286e537c054724f7ffa0164345f62b3e642029d7a80cc351918955328c4adc8a048823ef90b0cf38ea7db0d729caf2b633c3babe08b0310198c1081995c19029bc675193744eab9d7345b8a67258ec17d112cebdbbb2a281487dceeafb9d83aa930f32103fbe1d2911425bc5744002c7")]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Dynamic, PublicKey=0024000004800000940000000602000000240000525341310004000001000100cbd8d53b9d7de30f1f1278f636ec462cf9c254991291e66ebb157a885638a517887633b898ccbcf0d5c5ff7be85a6abe9e765d0ac7cd33c68dac67e7e64530e8222101109f154ab14a941c490ac155cd1d4fcba0fabb49016b4ef28593b015cab5937da31172f03f67d09edda404b88a60023f062ae71d0b2e4438b74cc11dc9")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9ca358aa-317b-4925-8ada-4a29e943a363")]
[assembly: CLSCompliant(true)]
[assembly: TargetFramework(".NETFramework,Version=v4.5", FrameworkDisplayName = ".NET Framework 4.5")]
[assembly: AssemblyCompany("Newtonsoft")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © James Newton-King 2008")]
[assembly: AssemblyDescription("Json.NET is a popular high-performance JSON framework for .NET")]
[assembly: AssemblyFileVersion("13.0.3.27908")]
[assembly: AssemblyInformationalVersion("13.0.3+0a2e291c0d9c0c7675d445703e51750363a549ef")]
[assembly: AssemblyProduct("Json.NET")]
[assembly: AssemblyTitle("Json.NET .NET 4.5")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/JamesNK/Newtonsoft.Json")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyVersion("13.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace 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
{
	public enum ConstructorHandling
	{
		Default,
		AllowNonPublicDefaultConstructor
	}
	public enum DateFormatHandling
	{
		IsoDateFormat,
		MicrosoftDateFormat
	}
	public enum DateParseHandling
	{
		None,
		DateTime,
		DateTimeOffset
	}
	public enum DateTimeZoneHandling
	{
		Local,
		Utc,
		Unspecified,
		RoundtripKind
	}
	public class DefaultJsonNameTable : JsonNameTable
	{
		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];
		}

		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]
	public enum DefaultValueHandling
	{
		Include = 0,
		Ignore = 1,
		Populate = 2,
		IgnoreAndPopulate = 3
	}
	public enum FloatFormatHandling
	{
		String,
		Symbol,
		DefaultValue
	}
	public enum FloatParseHandling
	{
		Double,
		Decimal
	}
	public enum Formatting
	{
		None,
		Indented
	}
	public interface IArrayPool<T>
	{
		T[] Rent(int minimumLength);

		void Return(T[]? array);
	}
	public interface IJsonLineInfo
	{
		int LineNumber { get; }

		int LinePosition { get; }

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

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

		public JsonArrayAttribute()
		{
		}

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

		public JsonArrayAttribute(string id)
			: base(id)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false)]
	public sealed class JsonConstructorAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
	public abstract class JsonContainerAttribute : Attribute
	{
		internal bool? _isReference;

		internal bool? _itemIsReference;

		internal ReferenceLoopHandling? _itemReferenceLoopHandling;

		internal TypeNameHandling? _itemTypeNameHandling;

		private Type? _namingStrategyType;

		private object[]? _namingStrategyParameters;

		public string? Id { get; set; }

		public string? Title { get; set; }

		public string? Description { get; set; }

		public Type? ItemConverterType { get; set; }

		public object[]? ItemConverterParameters { get; set; }

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

		public object[]? NamingStrategyParameters
		{
			get
			{
				return _namingStrategyParameters;
			}
			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()
		{
		}

		protected JsonContainerAttribute(string id)
		{
			Id = id;
		}
	}
	public 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";

		public static Func<JsonSerializerSettings>? DefaultSettings { get; set; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public static string ToString(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(string? value)
		{
			return ToString(value, '"');
		}

		public static string ToString(string? value, char delimiter)
		{
			return ToString(value, delimiter, StringEscapeHandling.Default);
		}

		public static string ToString(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(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(object? value)
		{
			return SerializeObject(value, (Type?)null, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		public static string SerializeObject(object? value, Formatting formatting)
		{
			return SerializeObject(value, formatting, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		public static string SerializeObject(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(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);
		}

		[DebuggerStepThrough]
		public static string SerializeObject(object? value, JsonSerializerSettings? settings)
		{
			return SerializeObject(value, null, settings);
		}

		[DebuggerStepThrough]
		public static string SerializeObject(object? value, Type? type, JsonSerializerSettings? settings)
		{
			JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
			return SerializeObjectInternal(value, type, jsonSerializer);
		}

		[DebuggerStepThrough]
		public static string SerializeObject(object? value, Formatting formatting, JsonSerializerSettings? settings)
		{
			return SerializeObject(value, null, formatting, settings);
		}

		[DebuggerStepThrough]
		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(object? value, 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]
		public static object? DeserializeObject(string value)
		{
			return DeserializeObject(value, (Type?)null, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		public static object? DeserializeObject(string value, JsonSerializerSettings settings)
		{
			return DeserializeObject(value, null, settings);
		}

		[DebuggerStepThrough]
		public static object? DeserializeObject(string value, Type type)
		{
			return DeserializeObject(value, type, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		public static T? DeserializeObject<T>(string value)
		{
			return JsonConvert.DeserializeObject<T>(value, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		public static T? DeserializeAnonymousType<T>(string value, T anonymousTypeObject)
		{
			return DeserializeObject<T>(value);
		}

		[DebuggerStepThrough]
		public static T? DeserializeAnonymousType<T>(string value, T anonymousTypeObject, JsonSerializerSettings settings)
		{
			return DeserializeObject<T>(value, settings);
		}

		[DebuggerStepThrough]
		public static T? DeserializeObject<T>(string value, params JsonConverter[] converters)
		{
			return (T)DeserializeObject(value, typeof(T), converters);
		}

		[DebuggerStepThrough]
		public static T? DeserializeObject<T>(string value, JsonSerializerSettings? settings)
		{
			return (T)DeserializeObject(value, typeof(T), settings);
		}

		[DebuggerStepThrough]
		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);
		}

		public static object? DeserializeObject(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, 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(XmlNode? node)
		{
			return SerializeXmlNode(node, Formatting.None);
		}

		public static string SerializeXmlNode(XmlNode? node, Formatting formatting)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		public static string SerializeXmlNode(XmlNode? node, Formatting formatting, bool omitRootObject)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
			{
				OmitRootObject = omitRootObject
			};
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		public static XmlDocument? DeserializeXmlNode(string value)
		{
			return DeserializeXmlNode(value, null);
		}

		public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName)
		{
			return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute: false);
		}

		public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
		{
			return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
		}

		public static XmlDocument? DeserializeXmlNode(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(XObject? node)
		{
			return SerializeXNode(node, Formatting.None);
		}

		public static string SerializeXNode(XObject? node, Formatting formatting)
		{
			return SerializeXNode(node, formatting, omitRootObject: false);
		}

		public static string SerializeXNode(XObject? node, Formatting formatting, bool omitRootObject)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
			{
				OmitRootObject = omitRootObject
			};
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		public static XDocument? DeserializeXNode(string value)
		{
			return DeserializeXNode(value, null);
		}

		public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName)
		{
			return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute: false);
		}

		public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
		{
			return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
		}

		public static XDocument? DeserializeXNode(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);
		}
	}
	public abstract class JsonConverter
	{
		public virtual bool CanRead => true;

		public virtual bool CanWrite => true;

		public abstract void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer);

		public abstract object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer);

		public abstract bool CanConvert(Type objectType);
	}
	public abstract class JsonConverter<T> : JsonConverter
	{
		public sealed override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
		{
			if (!((value != null) ? (value is T) : ReflectionUtils.IsNullable(typeof(T))))
			{
				throw new JsonSerializationException("Converter cannot write specified value to JSON. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
			}
			WriteJson(writer, (T)value, serializer);
		}

		public abstract void WriteJson(JsonWriter writer, T? value, JsonSerializer serializer);

		public sealed override object? ReadJson(JsonReader reader, Type objectType, 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);
		}

		public abstract T? ReadJson(JsonReader reader, Type objectType, T? existingValue, bool hasExistingValue, JsonSerializer serializer);

		public sealed override bool CanConvert(Type objectType)
		{
			return typeof(T).IsAssignableFrom(objectType);
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Parameter, AllowMultiple = false)]
	public sealed class JsonConverterAttribute : Attribute
	{
		private readonly Type _converterType;

		public Type ConverterType => _converterType;

		public object[]? ConverterParameters { 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;
		}
	}
	public class JsonConverterCollection : Collection<JsonConverter>
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
	public sealed class JsonDictionaryAttribute : JsonContainerAttribute
	{
		public JsonDictionaryAttribute()
		{
		}

		public JsonDictionaryAttribute(string id)
			: base(id)
		{
		}
	}
	[Serializable]
	public class JsonException : Exception
	{
		public JsonException()
		{
		}

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

		public JsonException(string message, 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)]
	public 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)]
	public sealed class JsonIgnoreAttribute : Attribute
	{
	}
	public abstract class JsonNameTable
	{
		public abstract string? Get(char[] key, int start, int length);
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, AllowMultiple = false)]
	public 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;
		}

		public JsonObjectAttribute(string id)
			: base(id)
		{
		}
	}
	internal enum JsonContainerType
	{
		None,
		Object,
		Array,
		Constructor
	}
	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;

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

		internal void WriteTo(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(IJsonLineInfo? lineInfo, string path, string message)
		{
			if (!message.EndsWith(Environment.NewLine, StringComparison.Ordinal))
			{
				message = message.Trim();
				if (!StringUtils.EndsWith(message, '.'))
				{
					message += ".";
				}
				message += " ";
			}
			message += "Path '{0}'".FormatWith(CultureInfo.InvariantCulture, path);
			if (lineInfo != null && lineInfo.HasLineInfo())
			{
				message += ", line {0}, position {1}".FormatWith(CultureInfo.InvariantCulture, lineInfo.LineNumber, lineInfo.LinePosition);
			}
			message += ".";
			return message;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false)]
	public 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; }

		public object[]? ItemConverterParameters { get; set; }

		public Type? NamingStrategyType { get; set; }

		public object[]? NamingStrategyParameters { get; 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()
		{
		}

		public JsonPropertyAttribute(string propertyName)
		{
			PropertyName = propertyName;
		}
	}
	public abstract class JsonReader : IDisposable
	{
		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;
			}
		}

		public virtual string Path
		{
			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);
			}
		}

		public CultureInfo Culture
		{
			get
			{
				return _culture ?? CultureInfo.InvariantCulture;
			}
			set
			{
				_culture = value;
			}
		}

		public virtual Task<bool> ReadAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<bool>() ?? Read().ToAsync();
		}

		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)
				{
				}
			}
		}

		internal async Task ReaderReadAndAssertAsync(CancellationToken cancellationToken)
		{
			if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
			{
				throw CreateUnexpectedEndException();
			}
		}

		public virtual Task<bool?> ReadAsBooleanAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<bool?>() ?? Task.FromResult(ReadAsBoolean());
		}

		public virtual Task<byte[]?> ReadAsBytesAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<byte[]>() ?? Task.FromResult(ReadAsBytes());
		}

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

		public virtual Task<DateTime?> ReadAsDateTimeAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<DateTime?>() ?? Task.FromResult(ReadAsDateTime());
		}

		public virtual Task<DateTimeOffset?> ReadAsDateTimeOffsetAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<DateTimeOffset?>() ?? Task.FromResult(ReadAsDateTimeOffset());
		}

		public virtual Task<decimal?> ReadAsDecimalAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<decimal?>() ?? Task.FromResult(ReadAsDecimal());
		}

		public virtual Task<double?> ReadAsDoubleAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return Task.FromResult(ReadAsDouble());
		}

		public virtual Task<int?> ReadAsInt32Async(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<int?>() ?? Task.FromResult(ReadAsInt32());
		}

		public virtual Task<string?> ReadAsStringAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return cancellationToken.CancelIfRequestedAsync<string>() ?? Task.FromResult(ReadAsString());
		}

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

		internal Task<bool> MoveToContentAsync(CancellationToken cancellationToken)
		{
			JsonToken tokenType = TokenType;
			if (tokenType == JsonToken.None || tokenType == JsonToken.Comment)
			{
				return MoveToContentFromNonContentAsync(cancellationToken);
			}
			return AsyncUtils.True;
		}

		private async Task<bool> MoveToContentFromNonContentAsync(CancellationToken cancellationToken)
		{
			JsonToken tokenType;
			do
			{
				if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
				{
					return false;
				}
				tokenType = TokenType;
			}
			while (tokenType == JsonToken.None || tokenType == JsonToken.Comment);
			return true;
		}

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

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

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

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

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

		public abstract bool Read();

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

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

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

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

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

		private bool ReadArrayElementIntoByteArrayReportDone(List<byte> buffer)
		{
			switch (TokenType)
			{
			case JsonToken.None:
				throw JsonReaderException.Create(this, "Unexpected end when reading bytes.");
			case JsonToken.Integer:
				buffer.Add(Convert.ToByte(Value, CultureInfo.InvariantCulture));
				return false;
			case JsonToken.EndArray:
				return true;
			case JsonToken.Comment:
				return false;
			default:
				throw JsonReaderException.Create(this, "Unexpected token when reading bytes: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
			}
		}

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

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

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

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

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

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

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

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

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

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

		internal void ReaderReadAndAssert()
		{
			if (!Read())
			{
				throw CreateUnexpectedEndException();
			}
		}

		internal JsonReaderException CreateUnexpectedEndException()
		{
			return JsonReaderException.Create(this, "Unexpected end when reading JSON.");
		}

		internal void ReadIntoWrappedTypeObject()
		{
			ReaderReadAndAssert();
			if (Value != null && Value.ToString() == "$type")
			{
				ReaderReadAndAssert();
				if (Value != null && Value.ToString().StartsWith("System.Byte[]", StringComparison.Ordinal))
				{
					ReaderReadAndAssert();
					if (Value.ToString() == "$value")
					{
						return;
					}
				}
			}
			throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, JsonToken.StartObject));
		}

		public void Skip()
		{
			if (TokenType == JsonToken.PropertyName)
			{
				Read();
			}
			if (JsonTokenUtils.IsStartToken(TokenType))
			{
				int depth = Depth;
				while (Read() && depth < Depth)
				{
				}
			}
		}

		protected void SetToken(JsonToken newToken)
		{
			SetToken(newToken, null, updateIndex: true);
		}

		protected void SetToken(JsonToken newToken, object? value)
		{
			SetToken(newToken, value, updateIndex: true);
		}

		protected void SetToken(JsonToken newToken, object? value, bool updateIndex)
		{
			_tokenType = newToken;
			_value = value;
			switch (newToken)
			{
			case JsonToken.StartObject:
				_currentState = State.ObjectStart;
				Push(JsonContainerType.Object);
				break;
			case JsonToken.StartArray:
				_currentState = State.ArrayStart;
				Push(JsonContainerType.Array);
				break;
			case JsonToken.StartConstructor:
				_currentState = State.ConstructorStart;
				Push(JsonContainerType.Constructor);
				break;
			case JsonToken.EndObject:
				ValidateEnd(JsonToken.EndObject);
				break;
			case JsonToken.EndArray:
				ValidateEnd(JsonToken.EndArray);
				break;
			case JsonToken.EndConstructor:
				ValidateEnd(JsonToken.EndConstructor);
				break;
			case JsonToken.PropertyName:
				_currentState = State.Property;
				_currentPosition.PropertyName = (string)value;
				break;
			case JsonToken.Raw:
			case JsonToken.Integer:
			case JsonToken.Float:
			case JsonToken.String:
			case JsonToken.Boolean:
			case JsonToken.Null:
			case JsonToken.Undefined:
			case JsonToken.Date:
			case JsonToken.Bytes:
				SetPostValueState(updateIndex);
				break;
			case JsonToken.Comment:
				break;
			}
		}

		internal void SetPostValueState(bool updateIndex)
		{
			if (Peek() != 0 || SupportMultipleContent)
			{
				_currentState = State.PostValue;
			}
			else
			{
				SetFinished();
			}
			if (updateIndex)
			{
				UpdateScopeWithFinishedValue();
			}
		}

		private void UpdateScopeWithFinishedValue()
		{
			if (_currentPosition.HasIndex)
			{
				_currentPosition.Position++;
			}
		}

		private void ValidateEnd(JsonToken endToken)
		{
			JsonContainerType jsonContainerType = Pop();
			if (GetTypeForCloseToken(endToken) != jsonContainerType)
			{
				throw JsonReaderException.Create(this, "JsonToken {0} is not valid for closing JsonType {1}.".FormatWith(CultureInfo.InvariantCulture, endToken, jsonContainerType));
			}
			if (Peek() != 0 || SupportMultipleContent)
			{
				_currentState = State.PostValue;
			}
			else
			{
				SetFinished();
			}
		}

		protected void SetStateBasedOnCurrent()
		{
			JsonContainerType jsonContainerType = Peek();
			switch (jsonContainerType)
			{
			case JsonContainerType.Object:
				_currentState = State.Object;
				break;
			case JsonContainerType.Array:
				_currentState = State.Array;
				break;
			case JsonContainerType.Constructor:
				_currentState = State.Constructor;
				break;
			case JsonContainerType.None:
				SetFinished();
				break;
			default:
				throw JsonReaderException.Create(this, "While setting the reader state back to current object an unexpected JsonType was encountered: {0}".FormatWith(CultureInfo.InvariantCulture, jsonContainerType));
			}
		}

		private void SetFinished()
		{
			_currentState = ((!SupportMultipleContent) ? State.Finished : State.Start);
		}

		private JsonContainerType GetTypeForCloseToken(JsonToken token)
		{
			return token switch
			{
				JsonToken.EndObject => JsonContainerType.Object, 
				JsonToken.EndArray => JsonContainerType.Array, 
				JsonToken.EndConstructor => JsonContainerType.Constructor, 
				_ => throw JsonReaderException.Create(this, "Not a valid close JsonToken: {0}".FormatWith(CultureInfo.InvariantCulture, token)), 
			};
		}

		void IDisposable.Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (_currentState != State.Closed && disposing)
			{
				Close();
			}
		}

		public virtual void Close()
		{
			_currentState = State.Closed;
			_tokenType = JsonToken.None;
			_value = null;
		}

		internal void ReadAndAssert()
		{
			if (!Read())
			{
				throw JsonSerializationException.Create(this, "Unexpected end when reading JSON.");
			}
		}

		internal void ReadForTypeAndAssert(JsonContract? contract, bool hasConverter)
		{
			if (!ReadForType(contract, hasConverter))
			{
				throw JsonSerializationException.Create(this, "Unexpected end when reading JSON.");
			}
		}

		internal bool ReadForType(JsonContract? contract, bool hasConverter)
		{
			if (hasConverter)
			{
				return Read();
			}
			switch (contract?.InternalReadType ?? ReadType.Read)
			{
			case ReadType.Read:
				return ReadAndMoveToContent();
			case ReadType.ReadAsInt32:
				ReadAsInt32();
				break;
			case ReadType.ReadAsInt64:
			{
				bool result = ReadAndMoveToContent();
				if (TokenType == JsonToken.Undefined)
				{
					throw JsonReaderException.Create(this, "An undefined token is not a valid {0}.".FormatWith(CultureInfo.InvariantCulture, contract?.UnderlyingType ?? typeof(long)));
				}
				return result;
			}
			case ReadType.ReadAsDecimal:
				ReadAsDecimal();
				break;
			case ReadType.ReadAsDouble:
				ReadAsDouble();
				break;
			case ReadType.ReadAsBytes:
				ReadAsBytes();
				break;
			case ReadType.ReadAsBoolean:
				ReadAsBoolean();
				break;
			case ReadType.ReadAsString:
				ReadAsString();
				break;
			case ReadType.ReadAsDateTime:
				ReadAsDateTime();
				break;
			case ReadType.ReadAsDateTimeOffset:
				ReadAsDateTimeOffset();
				break;
			default:
				throw new ArgumentOutOfRangeException();
			}
			return TokenType != JsonToken.None;
		}

		internal bool ReadAndMoveToContent()
		{
			if (Read())
			{
				return MoveToContent();
			}
			return false;
		}

		internal bool MoveToContent()
		{
			JsonToken tokenType = TokenType;
			while (tokenType == JsonToken.None || tokenType == JsonToken.Comment)
			{
				if (!Read())
				{
					return false;
				}
				tokenType = TokenType;
			}
			return true;
		}

		private JsonToken GetContentToken()
		{
			JsonToken tokenType;
			do
			{
				if (!Read())
				{
					SetToken(JsonToken.None);
					return JsonToken.None;
				}
				tokenType = TokenType;
			}
			while (tokenType == JsonToken.Comment);
			return tokenType;
		}
	}
	[Serializable]
	public class JsonReaderException : JsonException
	{
		public int LineNumber { get; }

		public int LinePosition { get; }

		public string? Path { get; }

		public JsonReaderException()
		{
		}

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

		public JsonReaderException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

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

		public JsonReaderException(string message, string path, int lineNumber, int linePosition, Exception? innerException)
			: base(message, innerException)
		{
			Path = path;
			LineNumber = lineNumber;
			LinePosition = linePosition;
		}

		internal static JsonReaderException Create(JsonReader reader, string message)
		{
			return Create(reader, message, null);
		}

		internal static JsonReaderException Create(JsonReader reader, string message, Exception? ex)
		{
			return Create(reader as IJsonLineInfo, reader.Path, message, ex);
		}

		internal static JsonReaderException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex)
		{
			message = JsonPosition.FormatMessage(lineInfo, path, message);
			int lineNumber;
			int linePosition;
			if (lineInfo != null && lineInfo.HasLineInfo())
			{
				lineNumber = lineInfo.LineNumber;
				linePosition = lineInfo.LinePosition;
			}
			else
			{
				lineNumber = 0;
				linePosition = 0;
			}
			return new JsonReaderException(message, path, lineNumber, linePosition, ex);
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	public sealed class JsonRequiredAttribute : Attribute
	{
	}
	[Serializable]
	public class JsonSerializationException : JsonException
	{
		public int LineNumber { get; }

		public int LinePosition { get; }

		public string? Path { get; }

		public JsonSerializationException()
		{
		}

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

		public JsonSerializationException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

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

		public JsonSerializationException(string message, string path, int lineNumber, int linePosition, Exception? innerException)
			: base(message, innerException)
		{
			Path = path;
			LineNumber = lineNumber;
			LinePosition = linePosition;
		}

		internal static JsonSerializationException Create(JsonReader reader, string message)
		{
			return Create(reader, message, null);
		}

		internal static JsonSerializationException Create(JsonReader reader, string message, Exception? ex)
		{
			return Create(reader as IJsonLineInfo, reader.Path, message, ex);
		}

		internal static JsonSerializationException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex)
		{
			message = JsonPosition.FormatMessage(lineInfo, path, message);
			int lineNumber;
			int linePosition;
			if (lineInfo != null && lineInfo.HasLineInfo())
			{
				lineNumber = lineInfo.LineNumber;
				linePosition = lineInfo.LinePosition;
			}
			else
			{
				lineNumber = 0;
				linePosition = 0;
			}
			return new JsonSerializationException(message, path, lineNumber, linePosition, ex);
		}
	}
	public class JsonSerializer
	{
		internal TypeNameHandling _typeNameHandling;

		internal TypeNameAssemblyFormatHandling _typeNameAssemblyFormatHandling;

		internal PreserveReferencesHandling _preserveReferencesHandling;

		internal ReferenceLoopHandling _referenceLoopHandling;

		internal MissingMemberHandling _missingMemberHandling;

		internal ObjectCreationHandling _objectCreationHandling;

		internal NullValueHandling _nullValueHandling;

		internal DefaultValueHandling _defaultValueHandling;

		internal ConstructorHandling _constructorHandling;

		internal MetadataPropertyHandling _metadataPropertyHandling;

		internal JsonConverterCollection? _converters;

		internal IContractResolver _contractResolver;

		internal ITraceWriter? _traceWriter;

		internal IEqualityComparer? _equalityComparer;

		internal ISerializationBinder _serializationBinder;

		internal StreamingContext _context;

		private IReferenceResolver? _referenceResolver;

		private Formatting? _formatting;

		private DateFormatHandling? _dateFormatHandling;

		private DateTimeZoneHandling? _dateTimeZoneHandling;

		private DateParseHandling? _dateParseHandling;

		private FloatFormatHandling? _floatFormatHandling;

		private FloatParseHandling? _floatParseHandling;

		private StringEscapeHandling? _stringEscapeHandling;

		private CultureInfo _culture;

		private int? _maxDepth;

		private bool _maxDepthSet;

		private bool? _checkAdditionalContent;

		private string? _dateFormatString;

		private bool _dateFormatStringSet;

		public virtual IReferenceResolver? ReferenceResolver
		{
			get
			{
				return GetReferenceResolver();
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value", "Reference resolver cannot be null.");
				}
				_referenceResolver = value;
			}
		}

		[Obsolete("Binder is obsolete. Use SerializationBinder instead.")]
		public virtual SerializationBinder Binder
		{
			get
			{
				if (_serializationBinder is SerializationBinder result)
				{
					return result;
				}
				if (_serializationBinder is SerializationBinderAdapter serializationBinderAdapter)
				{
					return serializationBinderAdapter.SerializationBinder;
				}
				throw new InvalidOperationException("Cannot get SerializationBinder because an ISerializationBinder was previously set.");
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value", "Serialization binder cannot be null.");
				}
				_serializationBinder = (value as ISerializationBinder) ?? new SerializationBinderAdapter(value);
			}
		}

		public virtual ISerializationBinder SerializationBinder
		{
			get
			{
				return _serializationBinder;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value", "Serialization binder cannot be null.");
				}
				_serializationBinder = value;
			}
		}

		public virtual ITraceWriter? TraceWriter
		{
			get
			{
				return _traceWriter;
			}
			set
			{
				_traceWriter = value;
			}
		}

		public virtual IEqualityComparer? EqualityComparer
		{
			get
			{
				return _equalityComparer;
			}
			set
			{
				_equalityComparer = value;
			}
		}

		public virtual TypeNameHandling TypeNameHandling
		{
			get
			{
				return _typeNameHandling;
			}
			set
			{
				if (value < TypeNameHandling.None || value > TypeNameHandling.Auto)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_typeNameHandling = value;
			}
		}

		[Obsolete("TypeNameAssemblyFormat is obsolete. Use TypeNameAssemblyFormatHandling instead.")]
		public virtual FormatterAssemblyStyle TypeNameAssemblyFormat
		{
			get
			{
				return (FormatterAssemblyStyle)_typeNameAssemblyFormatHandling;
			}
			set
			{
				if (value < FormatterAssemblyStyle.Simple || value > FormatterAssemblyStyle.Full)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_typeNameAssemblyFormatHandling = (TypeNameAssemblyFormatHandling)value;
			}
		}

		public virtual TypeNameAssemblyFormatHandling TypeNameAssemblyFormatHandling
		{
			get
			{
				return _typeNameAssemblyFormatHandling;
			}
			set
			{
				if (value < TypeNameAssemblyFormatHandling.Simple || value > TypeNameAssemblyFormatHandling.Full)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_typeNameAssemblyFormatHandling = value;
			}
		}

		public virtual PreserveReferencesHandling PreserveReferencesHandling
		{
			get
			{
				return _preserveReferencesHandling;
			}
			set
			{
				if (value < PreserveReferencesHandling.None || value > PreserveReferencesHandling.All)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_preserveReferencesHandling = value;
			}
		}

		public virtual ReferenceLoopHandling ReferenceLoopHandling
		{
			get
			{
				return _referenceLoopHandling;
			}
			set
			{
				if (value < ReferenceLoopHandling.Error || value > ReferenceLoopHandling.Serialize)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_referenceLoopHandling = value;
			}
		}

		public virtual MissingMemberHandling MissingMemberHandling
		{
			get
			{
				return _missingMemberHandling;
			}
			set
			{
				if (value < MissingMemberHandling.Ignore || value > MissingMemberHandling.Error)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_missingMemberHandling = value;
			}
		}

		public virtual NullValueHandling NullValueHandling
		{
			get
			{
				return _nullValueHandling;
			}
			set
			{
				if (value < NullValueHandling.Include || value > NullValueHandling.Ignore)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_nullValueHandling = value;
			}
		}

		public virtual DefaultValueHandling DefaultValueHandling
		{
			get
			{
				return _defaultValueHandling;
			}
			set
			{
				if (value < DefaultValueHandling.Include || value > DefaultValueHandling.IgnoreAndPopulate)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_defaultValueHandling = value;
			}
		}

		public virtual ObjectCreationHandling ObjectCreationHandling
		{
			get
			{
				return _objectCreationHandling;
			}
			set
			{
				if (value < ObjectCreationHandling.Auto || value > ObjectCreationHandling.Replace)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_objectCreationHandling = value;
			}
		}

		public virtual ConstructorHandling ConstructorHandling
		{
			get
			{
				return _constructorHandling;
			}
			set
			{
				if (value < ConstructorHandling.Default || value > ConstructorHandling.AllowNonPublicDefaultConstructor)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_constructorHandling = value;
			}
		}

		public virtual MetadataPropertyHandling MetadataPropertyHandling
		{
			get
			{
				return _metadataPropertyHandling;
			}
			set
			{
				if (value < MetadataPropertyHandling.Default || value > MetadataPropertyHandling.Ignore)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				_metadataPropertyHandling = value;
			}
		}

		public virtual JsonConverterCollection Converters
		{
			get
			{
				if (_converters == null)
				{
					_converters = new JsonConverterCollection();
				}
				return _converters;
			}
		}

		public virtual IContractResolver ContractResolver
		{
			get
			{
				return _contractResolver;
			}
			set
			{
				_contractResolver = value ?? DefaultContractResolver.Instance;
			}
		}

		public virtual StreamingContext Context
		{
			get
			{
				return _context;
			}
			set
			{
				_context = value;
			}
		}

		public virtual Formatting Formatting
		{
			get
			{
				return _formatting.GetValueOrDefault();
			}
			set
			{
				_formatting = value;
			}
		}

		public virtual DateFormatHandling DateFormatHandling
		{
			get
			{
				return _dateFormatHandling.GetValueOrDefault();
			}
			set
			{
				_dateFormatHandling = value;
			}
		}

		public virtual DateTimeZoneHandling DateTimeZoneHandling
		{
			get
			{
				return _dateTimeZoneHandling ?? DateTimeZoneHandling.RoundtripKind;
			}
			set
			{
				_dateTimeZoneHandling = value;
			}
		}

		public virtual DateParseHandling DateParseHandling
		{
			get
			{
				return _dateParseHandling ?? DateParseHandling.DateTime;
			}
			set
			{
				_dateParseHandling = value;
			}
		}

		public virtual FloatParseHandling FloatParseHandling
		{
			get
			{
				return _floatParseHandling.GetValueOrDefault();
			}
			set
			{
				_floatParseHandling = value;
			}
		}

		public virtual FloatFormatHandling FloatFormatHandling
		{
			get
			{
				return _floatFormatHandling.GetValueOrDefault();
			}
			set
			{
				_floatFormatHandling = value;
			}
		}

		public virtual StringEscapeHandling StringEscapeHandling
		{
			get
			{
				return _stringEscapeHandling.GetValueOrDefault();
			}
			set
			{
				_stringEscapeHandling = value;
			}
		}

		public virtual string DateFormatString
		{
			get
			{
				return _dateFormatString ?? "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
			}
			set
			{
				_dateFormatString = value;
				_dateFormatStringSet = true;
			}
		}

		public virtual CultureInfo Culture
		{
			get
			{
				return _culture ?? JsonSerializerSettings.DefaultCulture;
			}
			set
			{
				_culture = value;
			}
		}

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

		public virtual bool CheckAdditionalContent
		{
			get
			{
				return _checkAdditionalContent.GetValueOrDefault();
			}
			set
			{
				_checkAdditionalContent = value;
			}
		}

		public virtual event EventHandler<Newtonsoft.Json.Serialization.ErrorEventArgs>? Error;

		internal bool IsCheckAdditionalContentSet()
		{
			return _checkAdditionalContent.HasValue;
		}

		public JsonSerializer()
		{
			_referenceLoopHandling = ReferenceLoopHandling.Error;
			_missingMemberHandling = MissingMemberHandling.Ignore;
			_nullValueHandling = NullValueHandling.Include;
			_defaultValueHandling = DefaultValueHandling.Include;
			_objectCreationHandling = ObjectCreationHandling.Auto;
			_preserveReferencesHandling = PreserveReferencesHandling.None;
			_constructorHandling = ConstructorHandling.Default;
			_typeNameHandling = TypeNameHandling.None;
			_metadataPropertyHandling = MetadataPropertyHandling.Default;
			_context = JsonSerializerSettings.DefaultContext;
			_serializationBinder = DefaultSerializationBinder.Instance;
			_culture = JsonSerializerSettings.DefaultCulture;
			_contractResolver = DefaultContractResolver.Instance;
		}

		public static JsonSerializer Create()
		{
			return new JsonSerializer();
		}

		public static JsonSerializer Create(JsonSerializerSettings? settings)
		{
			JsonSerializer jsonSerializer = Create();
			if (settings != null)
			{
				ApplySerializerSettings(jsonSerializer, settings);
			}
			return jsonSerializer;
		}

		public static JsonSerializer CreateDefault()
		{
			return Create(JsonConvert.DefaultSettings?.Invoke());
		}

		public static JsonSerializer CreateDefault(JsonSerializerSettings? settings)
		{
			JsonSerializer jsonSerializer = CreateDefault();
			if (settings != null)
			{
				ApplySerializerSettings(jsonSerializer, settings);
			}
			return jsonSerializer;
		}

		private static void ApplySerializerSettings(JsonSerializer serializer, JsonSerializerSettings settings)
		{
			if (!CollectionUtils.IsNullOrEmpty(settings.Converters))
			{
				for (int i = 0; i < settings.Converters.Count; i++)
				{
					serializer.Converters.Insert(i, settings.Converters[i]);
				}
			}
			if (settings._typeNameHandling.HasValue)
			{
				serializer.TypeNameHandling = settings.TypeNameHandling;
			}
			if (settings._metadataPropertyHandling.HasValue)
			{
				serializer.MetadataPropertyHandling = settings.MetadataPropertyHandling;
			}
			if (settings._typeNameAssemblyFormatHandling.HasValue)
			{
				serializer.TypeNameAssemblyFormatHandling = settings.TypeNameAssemblyFormatHandling;
			}
			if (settings._preserveReferencesHandling.HasValue)
			{
				serializer.PreserveReferencesHandling = settings.PreserveReferencesHandling;
			}
			if (settings._referenceLoopHandling.HasValue)
			{
				serializer.ReferenceLoopHandling = settings.ReferenceLoopHandling;
			}
			if (settings._missingMemberHandling.HasValue)
			{
				serializer.MissingMemberHandling = settings.MissingMemberHandling;
			}
			if (settings._objectCreationHandling.HasValue)
			{
				serializer.ObjectCreationHandling = settings.ObjectCreationHandling;
			}
			if (settings._nullValueHandling.HasValue)
			{
				serializer.NullValueHandling = settings.NullValueHandling;
			}
			if (settings._defaultValueHandling.HasValue)
			{
				serializer.DefaultValueHandling = settings.DefaultValueHandling;
			}
			if (settings._constructorHandling.HasValue)
			{
				serializer.ConstructorHandling = settings.ConstructorHandling;
			}
			if (settings._context.HasValue)
			{
				serializer.Context = settings.Context;
			}
			if (settings._checkAdditionalContent.HasValue)
			{
				serializer._checkAdditionalContent = settings._checkAdditionalContent;
			}
			if (settings.Error != null)
			{
				serializer.Error += settings.Error;
			}
			if (settings.ContractResolver != null)
			{
				serializer.ContractResolver = settings.ContractResolver;
			}
			if (settings.ReferenceResolverProvider != null)
			{
				serializer.ReferenceResolver = settings.ReferenceResolverProvider();
			}
			if (settings.TraceWriter != null)
			{
				serializer.TraceWriter = settings.TraceWriter;
			}
			if (settings.EqualityComparer != null)
			{
				serializer.EqualityComparer = settings.EqualityComparer;
			}
			if (settings.SerializationBinder != null)
			{
				serializer.SerializationBinder = settings.SerializationBinder;
			}
			if (settings._formatting.HasValue)
			{
				serializer._formatting = settings._formatting;
			}
			if (settings._dateFormatHandling.HasValue)
			{
				serializer._dateFormatHandling = settings._dateFormatHandling;
			}
			if (settings._dateTimeZoneHandling.HasValue)
			{
				serializer._dateTimeZoneHandling = settings._dateTimeZoneHandling;
			}
			if (settings._dateParseHandling.HasValue)
			{
				serializer._dateParseHandling = settings._dateParseHandling;
			}
			if (settings._dateFormatStringSet)
			{
				serializer._dateFormatString = settings._dateFormatString;
				serializer._dateFormatStringSet = settings._dateFormatStringSet;
			}
			if (settings._floatFormatHandling.HasValue)
			{
				serializer._floatFormatHandling = settings._floatFormatHandling;
			}
			if (settings._floatParseHandling.HasValue)
			{
				serializer._floatParseHandling = settings._floatParseHandling;
			}
			if (settings._stringEscapeHandling.HasValue)
			{
				serializer._stringEscapeHandling = settings._stringEscapeHandling;
			}
			if (settings._culture != null)
			{
				serializer._culture = settings._culture;
			}
			if (settings._maxDepthSet)
			{
				serializer._maxDepth = settings._maxDepth;
				serializer._maxDepthSet = settings._maxDepthSet;
			}
		}

		[DebuggerStepThrough]
		public void Populate(TextReader reader, object target)
		{
			Populate(new JsonTextReader(reader), target);
		}

		[DebuggerStepThrough]
		public void Populate(JsonReader reader, object target)
		{
			PopulateInternal(reader, target);
		}

		internal virtual void PopulateInternal(JsonReader reader, object target)
		{
			ValidationUtils.ArgumentNotNull(reader, "reader");
			ValidationUtils.ArgumentNotNull(target, "target");
			SetupReader(reader, out CultureInfo previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string previousDateFormatString);
			TraceJsonReader traceJsonReader = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? CreateTraceJsonReader(reader) : null);
			new JsonSerializerInternalReader(this).Populate(traceJsonReader ?? reader, target);
			if (traceJsonReader != null)
			{
				TraceWriter.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null);
			}
			ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString);
		}

		[DebuggerStepThrough]
		public object? Deserialize(JsonReader reader)
		{
			return Deserialize(reader, null);
		}

		[DebuggerStepThrough]
		public object? Deserialize(TextReader reader, Type objectType)
		{
			return Deserialize(new JsonTextReader(reader), objectType);
		}

		[DebuggerStepThrough]
		public T? Deserialize<T>(JsonReader reader)
		{
			return (T)Deserialize(reader, typeof(T));
		}

		[DebuggerStepThrough]
		public object? Deserialize(JsonReader reader, Type? objectType)
		{
			return DeserializeInternal(reader, objectType);
		}

		internal virtual object? DeserializeInternal(JsonReader reader, Type? objectType)
		{
			ValidationUtils.ArgumentNotNull(reader, "reader");
			SetupReader(reader, out CultureInfo previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string previousDateFormatString);
			TraceJsonReader traceJsonReader = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? CreateTraceJsonReader(reader) : null);
			object? result = new JsonSerializerInternalReader(this).Deserialize(traceJsonReader ?? reader, objectType, CheckAdditionalContent);
			if (traceJsonReader != null)
			{
				TraceWriter.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null);
			}
			ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString);
			return result;
		}

		internal void SetupReader(JsonReader reader, out CultureInfo? previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string? previousDateFormatString)
		{
			if (_culture != null && !_culture.Equals(reader.Culture))
			{
				previousCulture = reader.Culture;
				reader.Culture = _culture;
			}
			else
			{
				previousCulture = null;
			}
			if (_dateTimeZoneHandling.HasValue && reader.DateTimeZoneHandling != _dateTimeZoneHandling)
			{
				previousDateTimeZoneHandling = reader.DateTimeZoneHandling;
				reader.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault();
			}
			else
			{
				previousDateTimeZoneHandling = null;
			}
			if (_dateParseHandling.HasValue && reader.DateParseHandling != _dateParseHandling)
			{
				previousDateParseHandling = reader.DateParseHandling;
				reader.DateParseHandling = _dateParseHandling.GetValueOrDefault();
			}
			else
			{
				previousDateParseHandling = null;
			}
			if (_floatParseHandling.HasValue && reader.FloatParseHandling != _floatParseHandling)
			{
				previousFloatParseHandling = reader.FloatParseHandling;
				reader.FloatParseHandling = _floatParseHandling.GetValueOrDefault();
			}
			else
			{
				previousFloatParseHandling = null;
			}
			if (_maxDepthSet && reader.MaxDepth != _maxDepth)
			{
				previousMaxDepth = reader.MaxDepth;
				reader.MaxDepth = _maxDepth;
			}
			else
			{
				previousMaxDepth = null;
			}
			if (_dateFormatStringSet && reader.DateFormatString != _dateFormatString)
			{
				previousDateFormatString = reader.DateFormatString;
				reader.DateFormatString = _dateFormatString;
			}
			else
			{
				previousDateFormatString = null;
			}
			if (reader is JsonTextReader jsonTextReader && jsonTextReader.PropertyNameTable == null && _contractResolver is DefaultContractResolver defaultContractResolver)
			{
				jsonTextReader.PropertyNameTable = defaultContractResolver.GetNameTable();
			}
		}

		private void ResetReader(JsonReader reader, CultureInfo? previousCulture, DateTimeZoneHandling? previousDateTimeZoneHandling, DateParseHandling? previousDateParseHandling, FloatParseHandling? previousFloatParseHandling, int? previousMaxDepth, string? previousDateFormatString)
		{
			if (previousCulture != null)
			{
				reader.Culture = previousCulture;
			}
			if (previousDateTimeZoneHandling.HasValue)
			{
				reader.DateTimeZoneHandling = previousDateTimeZoneHandling.GetValueOrDefault();
			}
			if (previousDateParseHandling.HasValue)
			{
				reader.DateParseHandling = previousDateParseHandling.GetValueOrDefault();
			}
			if (previousFloatParseHandling.HasValue)
			{
				reader.FloatParseHandling = previousFloatParseHandling.GetValueOrDefault();
			}
			if (_maxDepthSet)
			{
				reader.MaxDepth = previousMaxDepth;
			}
			if (_dateFormatStringSet)
			{
				reader.DateFormatString = previousDateFormatString;
			}
			if (reader is JsonTextReader jsonTextReader && jsonTextReader.PropertyNameTable != null && _contractResolver is DefaultContractResolver defaultContractResolver && jsonTextReader.PropertyNameTable == defaultContractResolver.GetNameTable())
			{
				jsonTextReader.PropertyNameTable = null;
			}
		}

		public void Serialize(TextWriter textWriter, object? value)
		{
			Serialize(new JsonTextWriter(textWriter), value);
		}

		public void Serialize(JsonWriter jsonWriter, object? value, Type? objectType)
		{
			SerializeInternal(jsonWriter, value, objectType);
		}

		public void Serialize(TextWriter textWriter, object? value, Type objectType)
		{
			Serialize(new JsonTextWriter(textWriter), value, objectType);
		}

		public void Serialize(JsonWriter jsonWriter, object? value)
		{
			SerializeInternal(jsonWriter, value, null);
		}

		private TraceJsonReader CreateTraceJsonReader(JsonReader reader)
		{
			TraceJsonReader traceJsonReader = new TraceJsonReader(reader);
			if (reader.TokenType != 0)
			{
				traceJsonReader.WriteCurrentToken();
			}
			return traceJsonReader;
		}

		internal virtual void SerializeInternal(JsonWriter jsonWriter, object? value, Type? objectType)
		{
			ValidationUtils.ArgumentNotNull(jsonWriter, "jsonWriter");
			Formatting? formatting = null;
			if (_formatting.HasValue && jsonWriter.Formatting != _formatting)
			{
				formatting = jsonWriter.Formatting;
				jsonWriter.Formatting = _formatting.GetValueOrDefault();
			}
			DateFormatHandling? dateFormatHandling = null;
			if (_dateFormatHandling.HasValue && jsonWriter.DateFormatHandling != _dateFormatHandling)
			{
				dateFormatHandling = jsonWriter.DateFormatHandling;
				jsonWriter.DateFormatHandling = _dateFormatHandling.GetValueOrDefault();
			}
			DateTimeZoneHandling? dateTimeZoneHandling = null;
			if (_dateTimeZoneHandling.HasValue && jsonWriter.DateTimeZoneHandling != _dateTimeZoneHandling)
			{
				dateTimeZoneHandling = jsonWriter.DateTimeZoneHandling;
				jsonWriter.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault();
			}
			FloatFormatHandling? floatFormatHandling = null;
			if (_floatFormatHandling.HasValue && jsonWriter.FloatFormatHandling != _floatFormatHandling)
			{
				floatFormatHandling = jsonWriter.FloatFormatHandling;
				jsonWriter.FloatFormatHandling = _floatFormatHandling.GetValueOrDefault();
			}
			StringEscapeHandling? stringEscapeHandling = null;
			if (_stringEscapeHandling.HasValue && jsonWriter.StringEscapeHandling != _stringEscapeHandling)
			{
				stringEscapeHandling = jsonWriter.StringEscapeHandling;
				jsonWriter.StringEscapeHandling = _stringEscapeHandling.GetValueOrDefault();
			}
			CultureInfo cultureInfo = null;
			if (_culture != null && !_culture.Equals(jsonWriter.Culture))
			{
				cultureInfo = jsonWriter.Culture;
				jsonWriter.Culture = _culture;
			}
			string dateFormatString = null;
			if (_dateFormatStringSet && jsonWriter.DateFormatString != _dateFormatString)
			{
				dateFormatString = jsonWriter.DateFormatString;
				jsonWriter.DateFormatString = _dateFormatString;
			}
			TraceJsonWriter traceJsonWriter = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? new TraceJsonWriter(jsonWriter) : null);
			new JsonSerializerInternalWriter(this).Serialize(traceJsonWriter ?? jsonWriter, value, objectType);
			if (traceJsonWriter != null)
			{
				TraceWriter.Trace(TraceLevel.Verbose, traceJsonWriter.GetSerializedJsonMessage(), null);
			}
			if (formatting.HasValue)
			{
				jsonWriter.Formatting = formatting.GetValueOrDefault();
			}
			if (dateFormatHandling.HasValue)
			{
				jsonWriter.DateFormatHandling = dateFormatHandling.GetValueOrDefault();
			}
			if (dateTimeZoneHandling.HasValue)
			{
				jsonWriter.DateTimeZoneHandling = dateTimeZoneHandling.GetValueOrDefault();
			}
			if (floatFormatHandling.HasValue)
			{
				jsonWriter.FloatFormatHandling = floatFormatHandling.GetValueOrDefault();
			}
			if (stringEscapeHandling.HasValue)
			{
				jsonWriter.StringEscapeHandling = stringEscapeHandling.GetValueOrDefault();
			}
			if (_dateFormatStringSet)
			{
				jsonWriter.DateFormatString = dateFormatString;
			}
			if (cultureInfo != null)
			{
				jsonWriter.Culture = cultureInfo;
			}
		}

		internal IReferenceResolver GetReferenceResolver()
		{
			if (_referenceResolver == null)
			{
				_referenceResolver = new DefaultReferenceResolver();
			}
			return _referenceResolver;
		}

		internal JsonConverter? GetMatchingConverter(Type type)
		{
			return GetMatchingConverter(_converters, type);
		}

		internal static JsonConverter? GetMatchingConverter(IList<JsonConverter>? converters, Type objectType)
		{
			if (converters != null)
			{
				for (int i = 0; i < converters.Count; i++)
				{
					JsonConverter jsonConverter = converters[i];
					if (jsonConverter.CanConvert(objectType))
					{
						return jsonConverter;
					}
				}
			}
			return null;
		}

		internal void OnError(Newtonsoft.Json.Serialization.ErrorEventArgs e)
		{
			this.Error?.Invoke(this, e);
		}
	}
	public class JsonSerializerSettings
	{
		internal const ReferenceLoopHandling DefaultReferenceLoopHandling = ReferenceLoopHandling.Error;

		internal const MissingMemberHandling DefaultMissingMemberHandling = MissingMemberHandling.Ignore;

		internal const NullValueHandling DefaultNullValueHandling = NullValueHandling.Include;

		internal const DefaultValueHandling DefaultDefaultValueHandling = DefaultValueHandling.Include;

		internal const ObjectCreationHandling DefaultObjectCreationHandling = ObjectCreationHandling.Auto;

		internal const PreserveReferencesHandling DefaultPreserveReferencesHandling = PreserveReferencesHandling.None;

		internal const ConstructorHandling DefaultConstructorHandling = ConstructorHandling.Default;

		internal const TypeNameHandling DefaultTypeNameHandling = TypeNameHandling.None;

		internal const MetadataPropertyHandling DefaultMetadataPropertyHandling = MetadataPropertyHandling.Default;

		internal static readonly StreamingContext DefaultContext;

		internal const Formatting DefaultFormatting = Formatting.None;

		internal const DateFormatHandling DefaultDateFormatHandling = DateFormatHandling.IsoDateFormat;

		internal const DateTimeZoneHandling DefaultDateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;

		internal const DateParseHandling DefaultDateParseHandling = DateParseHandling.DateTime;

		internal const FloatParseHandling DefaultFloatParseHandling = FloatParseHandling.Double;

		internal const FloatFormatHandling DefaultFloatFormatHandling = FloatFormatHandling.String;

		internal const StringEscapeHandling DefaultStringEscapeHandling = StringEscapeHandling.Default;

		internal const TypeNameAssemblyFormatHandling DefaultTypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple;

		internal static readonly CultureInfo DefaultCulture;

		internal const bool DefaultCheckAdditionalContent = false;

		internal const string DefaultDateFormatString = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";

		internal const int DefaultMaxDepth = 64;

		internal Formatting? _formatting;

		internal DateFormatHandling? _dateFormatHandling;

		internal DateTimeZoneHandling? _dateTimeZoneHandling;

		internal DateParseHandling? _dateParseHandling;

		internal FloatFormatHandling? _floatFormatHandling;

		internal FloatParseHandling? _floatParseHandling;

		internal StringEscapeHandling? _stringEscapeHandling;

		internal CultureInfo? _culture;

		internal bool? _checkAdditionalContent;

		internal int? _maxDepth;

		internal bool _maxDepthSet;

		internal string? _dateFormatString;

		internal bool _dateFormatStringSet;

		internal TypeNameAssemblyFormatHandling? _typeNameAssemblyFormatHandling;

		internal DefaultValueHandling? _defaultValueHandling;

		internal PreserveReferencesHandling? _preserveReferencesHandling;

		internal NullValueHandling? _nullValueHandling;

		internal ObjectCreationHandling? _objectCreationHandling;

		internal MissingMemberHandling? _missingMemberHandling;

		internal ReferenceLoopHandling? _referenceLoopHandling;

		internal StreamingContext? _context;

		internal ConstructorHandling? _constructorHandling;

		internal TypeNameHandling? _typeNameHandling;

		internal MetadataPropertyHandling? _metadataPropertyHandling;

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

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

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

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

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

		public IList<JsonConverter> Converters { get; set; }

		public PreserveReferencesHandling PreserveReferencesHandling
		{
			get
			{
				return _preserveReferencesHandling.GetValueOrDef

GreyAnnouncer.dll

Decompiled a month ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using PluginConfig.API;
using PluginConfig.API.Decorators;
using PluginConfig.API.Fields;
using PluginConfig.API.Functionals;
using TMPro;
using UnityEngine;
using UnityEngine.Networking;
using greycsont.GreyAnnouncer;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("GreyAnnouncer")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("My first plugin")]
[assembly: AssemblyFileVersion("0.0.1.0")]
[assembly: AssemblyInformationalVersion("0.0.1")]
[assembly: AssemblyProduct("GreyAnnouncer")]
[assembly: AssemblyTitle("GreyAnnouncer")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class AudioSourcePool : MonoBehaviour
{
	private Queue<AudioSource> m_pool = new Queue<AudioSource>();

	private readonly HashSet<AudioSource> m_activeAudioSources = new HashSet<AudioSource>();

	private LinkedList<AudioSource> m_playingList = new LinkedList<AudioSource>();

	private Dictionary<AudioSource, LinkedListNode<AudioSource>> m_playingMap = new Dictionary<AudioSource, LinkedListNode<AudioSource>>();

	private static AudioSourcePool m_instance;

	public int initialSize = 2;

	public int maxSize = 7;

	public static AudioSourcePool Instance
	{
		get
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if ((Object)(object)m_instance == (Object)null)
			{
				GameObject val = new GameObject("AudioSourcePool");
				Object.DontDestroyOnLoad((Object)(object)val);
				m_instance = val.AddComponent<AudioSourcePool>();
				m_instance.Initialize();
			}
			return m_instance;
		}
	}

	private void Initialize()
	{
		for (int i = 0; i < initialSize; i++)
		{
			AudioSource item = CreateNewAudioSource();
			m_pool.Enqueue(item);
		}
	}

	public void PlayOneShot(AudioClip clip, AudioSourceSetting config)
	{
		AudioSource audioSource = Get();
		audioSource = AudioSourceManager.ConfigureAudioSource(audioSource, config);
		audioSource.clip = clip;
		UnderwaterController_inWater_Instance.CheckIsInWater();
		audioSource.Play();
		((MonoBehaviour)this).StartCoroutine(RecycleAfterPlay(audioSource));
	}

	public void AddAudioLowPassFilterToActiveAudioSource()
	{
		foreach (AudioSource activeAudioSource in m_activeAudioSources)
		{
			if ((Object)(object)activeAudioSource != (Object)null && ((Component)activeAudioSource).gameObject.activeInHierarchy)
			{
				AudioSourceManager.AddLowPassFilter(activeAudioSource);
			}
		}
	}

	public void RemoveAudioLowPassFilterFromActiveAudioSource()
	{
		foreach (AudioSource activeAudioSource in m_activeAudioSources)
		{
			if ((Object)(object)activeAudioSource != (Object)null && ((Component)activeAudioSource).gameObject.activeInHierarchy)
			{
				AudioSourceManager.RemoveLowPassFilter(activeAudioSource);
			}
		}
	}

	public void UpdateAllActiveSourcesVolume(float targetVolume, float duration = 0.35f)
	{
		foreach (AudioSource activeAudioSource in m_activeAudioSources)
		{
			if ((Object)(object)activeAudioSource != (Object)null && ((Component)activeAudioSource).gameObject.activeInHierarchy && activeAudioSource.isPlaying)
			{
				((MonoBehaviour)this).StartCoroutine(AudioSourceManager.FadeVolume(activeAudioSource, targetVolume, duration));
			}
		}
	}

	private AudioSource Get()
	{
		if (m_activeAudioSources.Count >= maxSize && m_playingList.Count > 0)
		{
			LinkedListNode<AudioSource> first = m_playingList.First;
			m_playingList.RemoveFirst();
			m_playingMap.Remove(first.Value);
			LogManager.LogWarning("Max audio sources reached, forcibly recycling the oldest source.");
			Recycle(first.Value);
		}
		AudioSource val = ((m_pool.Count > 0) ? m_pool.Dequeue() : CreateNewAudioSource());
		((Component)val).gameObject.SetActive(true);
		m_activeAudioSources.Add(val);
		LinkedListNode<AudioSource> value = m_playingList.AddLast(val);
		m_playingMap[val] = value;
		return val;
	}

	private AudioSource CreateNewAudioSource()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Expected O, but got Unknown
		LogManager.LogInfo("Create a new Audio Source");
		GameObject val = new GameObject("PooledAudioSource");
		val.transform.SetParent(((Component)this).transform);
		AudioSource result = val.AddComponent<AudioSource>();
		val.SetActive(false);
		return result;
	}

	private IEnumerator RecycleAfterPlay(AudioSource audioSource)
	{
		yield return (object)new WaitForSeconds(audioSource.clip.length);
		if (m_playingMap.TryGetValue(audioSource, out var node))
		{
			m_playingList.Remove(node);
			m_playingMap.Remove(audioSource);
		}
		Recycle(audioSource);
	}

	private void Recycle(AudioSource audioSource)
	{
		if (!((Object)(object)audioSource == (Object)null))
		{
			audioSource.Stop();
			audioSource.clip = null;
			((Component)audioSource).gameObject.SetActive(false);
			m_activeAudioSources.Remove(audioSource);
			m_pool.Enqueue(audioSource);
		}
	}
}
public class SoloAudioSource : MonoBehaviour
{
	private AudioSource m_audioSource;

	private static SoloAudioSource m_instance;

	public static SoloAudioSource Instance
	{
		get
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if ((Object)(object)m_instance == (Object)null)
			{
				GameObject val = new GameObject("SoloAudioSource");
				Object.DontDestroyOnLoad((Object)(object)val);
				m_instance = val.AddComponent<SoloAudioSource>();
			}
			return m_instance;
		}
	}

	public void PlayOneShot(AudioClip clip, AudioSourceSetting config)
	{
		if ((Object)(object)m_audioSource == (Object)null)
		{
			m_audioSource = ((Component)this).gameObject.AddComponent<AudioSource>();
			m_audioSource = AudioSourceManager.ConfigureAudioSource(m_audioSource, config);
		}
		m_audioSource.clip = clip;
		UnderwaterController_inWater_Instance.CheckIsInWater();
		m_audioSource.Play();
	}

	public void AddAudioLowPassFilter()
	{
		m_audioSource = AudioSourceManager.AddLowPassFilter(m_audioSource);
	}

	public void RemoveAudioLowPassFilter()
	{
		m_audioSource = AudioSourceManager.RemoveLowPassFilter(m_audioSource);
	}

	public void UpdateSoloAudioSourceVolume(float targetVolume, float duration = 0.35f)
	{
		if ((Object)(object)m_audioSource != (Object)null)
		{
			((MonoBehaviour)this).StartCoroutine(AudioSourceManager.FadeVolume(m_audioSource, targetVolume, duration));
		}
	}
}
public static class GuidPrefixAdder
{
	public static string AddPrefixToGUID(string rankKey)
	{
		return "GreyAnnouncer_" + rankKey.ToUpper();
	}

	public static string RemovePrefixFromGUID(string guid)
	{
		if (guid.StartsWith("GreyAnnouncer_"))
		{
			return guid.Substring("GreyAnnouncer_".Length);
		}
		return guid;
	}
}
namespace greycsont.GreyAnnouncer
{
	public class AudioAnnouncer
	{
		private AnnouncerJsonSetting m_jsonSetting;

		private AudioLoader m_audioLoader;

		private CooldownManager m_cooldownManager;

		private AudioSourceSetting m_audioSourceConfig;

		private string[] m_audioCategories;

		private string m_audioPath;

		public void Initialize(string[] audioCategories, AnnouncerJsonSetting jsonSetting, string audioPath)
		{
			VariableInitialization(audioCategories, jsonSetting, audioPath);
			ComponentInitialization();
		}

		[Description("Parry balls of Maurice -> Hit Maurice -> AscendingRank() -> Postfix() -> PlaySound() -> CheckPlayValidation(), This error will skip all the function before CheckPlayValidation(), That's why try-catch has implemented in the fucntion")]
		public void PlayAudioViaCategory(string category)
		{
			try
			{
				if (ValidateAndLogPlayback(category))
				{
					PlayAudioClip(category);
					SetCooldown(category, InstanceConfig.individualPlayCooldown.Value);
				}
			}
			catch (Exception ex)
			{
				LogPlaybackError(ex);
			}
		}

		public void PlayAudioViaIndex(int index)
		{
			PlayAudioViaCategory(m_audioCategories[index]);
		}

		public void ReloadAudio(AnnouncerJsonSetting jsonSetting)
		{
			m_jsonSetting = jsonSetting;
			m_audioLoader.UpdateAudioFileNames(m_jsonSetting);
			m_audioLoader.FindAvailableAudioAsync();
		}

		public void UpdateAudioPath(string newAudioPaths)
		{
			m_audioLoader.UpdateAudioPath(newAudioPaths);
		}

		public void ResetCooldown()
		{
			m_cooldownManager.ResetCooldowns();
		}

		public void ClearAudioClipsCache()
		{
			m_audioLoader.ClearCache();
		}

		public void UpdateJsonSetting(AnnouncerJsonSetting jsonSetting)
		{
			m_jsonSetting = jsonSetting;
			m_audioLoader.UpdateAudioFileNames(jsonSetting);
		}

		private void VariableInitialization(string[] audioCategories, AnnouncerJsonSetting jsonSetting, string audioPath)
		{
			m_jsonSetting = jsonSetting;
			m_audioPath = audioPath;
			m_audioCategories = audioCategories;
			m_audioSourceConfig = new AudioSourceSetting
			{
				SpatialBlend = 0f,
				Priority = 0,
				Volume = InstanceConfig.audioSourceVolume.Value,
				Pitch = 1f
			};
		}

		private void ComponentInitialization()
		{
			AudioLoaderInitialization();
			CooldownManagerInitialization();
		}

		private void AudioLoaderInitialization()
		{
			m_audioLoader = new AudioLoader(m_audioPath, m_audioCategories, m_jsonSetting);
			m_audioLoader.FindAvailableAudioAsync();
		}

		private void CooldownManagerInitialization()
		{
			m_cooldownManager = new CooldownManager(m_audioCategories);
		}

		public void SetCooldown(string category, float cooldown)
		{
			m_cooldownManager.StartSharedCooldown(InstanceConfig.sharedPlayCooldown.Value);
			m_cooldownManager.StartIndividualCooldown(category, cooldown);
		}

		private bool ValidateAndLogPlayback(string category)
		{
			ValidationState playValidationState = GetPlayValidationState(category);
			if (playValidationState != 0)
			{
				LogManager.LogInfo($"PlayValidationState: {category}, {playValidationState}");
				return false;
			}
			return true;
		}

		private void PlayAudioClip(string category)
		{
			switch (InstanceConfig.audioLoadingOptions.Value)
			{
			case 0:
				LoadAndPlayAudioClip(category);
				break;
			case 1:
				PlayAudioClipFromAudioClips(category);
				break;
			default:
				LogManager.LogWarning("Invalid play audio options, using the default one");
				LoadAndPlayAudioClip(category);
				break;
			}
		}

		private void PlayAudioClipFromAudioClips(string category)
		{
			AudioClip val = null;
			val = (InstanceConfig.isAudioRandomizationEnabled.Value ? m_audioLoader.GetRandomClipFromAudioClips() : m_audioLoader.GetClipFromCache(category));
			if (!((Object)(object)val == (Object)null))
			{
				AudioDispatcher.SendClipToAudioSource(val, m_audioSourceConfig);
			}
		}

		private async Task LoadAndPlayAudioClip(string category)
		{
			long currentRequestId = ++AnnouncerManager.playRequestId;
			AudioClip clip = (InstanceConfig.isAudioRandomizationEnabled.Value ? (await m_audioLoader.GetRandomClipFromAllAvailableFiles()) : (await m_audioLoader.LoadAndGetSingleAudioClipAsync(category)));
			if (!((Object)(object)clip == (Object)null))
			{
				if (currentRequestId != AnnouncerManager.playRequestId && InstanceConfig.audioPlayOptions.Value == 0)
				{
					LogManager.LogInfo("Aborted outdated audio request for: " + category);
				}
				else
				{
					AudioDispatcher.SendClipToAudioSource(clip, m_audioSourceConfig);
				}
			}
		}

		private void LogPlaybackError(Exception ex)
		{
			LogManager.LogError("An error occurred while playing sound: " + ex.Message);
			LogManager.LogError(ex.StackTrace);
		}

		private ValidationState GetPlayValidationState(string category)
		{
			if (m_cooldownManager == null || m_audioLoader == null)
			{
				return ValidationState.ComponentsNotInitialized;
			}
			if (m_audioLoader.audioCategories == null || !m_audioLoader.audioCategories.Contains(category))
			{
				return ValidationState.InvalidKey;
			}
			if (m_cooldownManager.IsIndividualCooldownActive(category))
			{
				return ValidationState.IndividualCooldown;
			}
			if (m_cooldownManager.IsSharedCooldownActive())
			{
				return ValidationState.SharedCooldown;
			}
			if (!m_jsonSetting.CategoryAudioMap[category].Enabled)
			{
				return ValidationState.DisabledByConfig;
			}
			return ValidationState.Success;
		}
	}
	public static class AudioClipLoader
	{
		public static async Task<AudioClip> LoadAudioClipAsync(string path)
		{
			string extension = Path.GetExtension(path).ToLower();
			AudioType? unityAudioType = GetUnityAudioType(extension);
			if (!unityAudioType.HasValue)
			{
				LogManager.LogError("Unsupported audio format: 「" + extension + "」 for " + path);
				return null;
			}
			try
			{
				LogManager.LogInfo("Started loading audio: " + path);
				return await LoadWithUnityAsync(path, unityAudioType.Value);
			}
			catch (Exception ex)
			{
				LogManager.LogError("Error loading " + path + ": " + ex.Message);
				return null;
			}
		}

		private static async Task<AudioClip> LoadWithUnityAsync(string path, AudioType audioType)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			string url = new Uri(path).AbsoluteUri;
			UnityWebRequest www = UnityWebRequestMultimedia.GetAudioClip(url, audioType);
			try
			{
				UnityWebRequestAsyncOperation operation = www.SendWebRequest();
				while (!((AsyncOperation)operation).isDone)
				{
					await Task.Delay(10);
				}
				if ((int)www.result != 1)
				{
					LogManager.LogError("UnityRequest Failed to load audio: " + www.error);
					return null;
				}
				AudioClip clip = DownloadHandlerAudioClip.GetContent(www);
				LogManager.LogInfo("Loaded audio: " + Path.GetFileName(path));
				return clip;
			}
			finally
			{
				((IDisposable)www)?.Dispose();
			}
		}

		private static AudioType? GetUnityAudioType(string extension)
		{
			if (1 == 0)
			{
			}
			AudioType? result = extension switch
			{
				".wav" => (AudioType)20, 
				".mp3" => (AudioType)13, 
				".ogg" => (AudioType)14, 
				".aiff" => (AudioType)2, 
				".aif" => (AudioType)2, 
				".acc" => (AudioType)1, 
				_ => null, 
			};
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public class AnnouncerJsonSetting
	{
		public Dictionary<string, CategoryAudioSetting> CategoryAudioMap { get; set; }
	}
	public class CategoryAudioSetting
	{
		public bool Enabled { get; set; } = true;


		public string DisplayName { get; set; }

		public List<string> AudioFiles { get; set; } = new List<string>();

	}
	public class AudioLoader
	{
		private Dictionary<string, List<AudioClip>> m_audioClips = new Dictionary<string, List<AudioClip>>();

		private AnnouncerJsonSetting m_jsonSetting;

		private string m_audioPath;

		public static Action<string> OnPluginConfiguratorLogUpdated;

		public string[] audioCategories { get; private set; }

		public HashSet<string> categoryFailedLoading { get; private set; } = new HashSet<string>();


		[Description("Q : Why do you using whole AnnouncerJsonSetting as input instead only CategoryAudioMap?A : For future, what kinds of future? idk.")]
		public AudioLoader(string audioPath, string[] audioCategories, AnnouncerJsonSetting jsonSetting)
		{
			m_audioPath = audioPath;
			this.audioCategories = audioCategories;
			m_jsonSetting = jsonSetting;
		}

		public AudioClip GetClipFromCache(string category)
		{
			if (categoryFailedLoading.Contains(category))
			{
				return null;
			}
			if (!audioCategories.Contains(category))
			{
				return null;
			}
			if (!m_audioClips.TryGetValue(category, out var value) || value.Count == 0)
			{
				return null;
			}
			int index = Random.Range(0, value.Count);
			return value[index];
		}

		public AudioClip GetRandomClipFromAudioClips()
		{
			List<AudioClip> list = (from clip in m_audioClips.SelectMany((KeyValuePair<string, List<AudioClip>> kvp) => kvp.Value)
				where (Object)(object)clip != (Object)null
				select clip).ToList();
			return list[Random.Range(0, list.Count)];
		}

		public async Task<AudioClip> LoadAndGetSingleAudioClipAsync(string category)
		{
			if (!TryGetValidAudioFiles(category, out var validFiles))
			{
				return null;
			}
			string selectedPath = validFiles[Random.Range(0, validFiles.Count)];
			AudioClip clip = await AudioClipLoader.LoadAudioClipAsync(selectedPath);
			if ((Object)(object)clip == (Object)null)
			{
				LogCategoryFailure(category, "Selected file failed to load");
			}
			return clip;
		}

		public async Task<AudioClip> GetRandomClipFromAllAvailableFiles()
		{
			List<string> totalValidFiles = new List<string>();
			string[] array = audioCategories;
			foreach (string category in array)
			{
				TryGetValidAudioFiles(category, out var validFiles);
				foreach (string fileName in validFiles)
				{
					totalValidFiles.Add(fileName);
				}
				validFiles = null;
			}
			if (totalValidFiles.Count == 0)
			{
				throw new ArgumentOutOfRangeException("114514");
			}
			string selectedPath = totalValidFiles[Random.Range(0, totalValidFiles.Count)];
			AudioClip clip = await AudioClipLoader.LoadAudioClipAsync(selectedPath);
			if ((Object)(object)clip == (Object)null)
			{
				LogCategoryFailure(selectedPath, "Selected file failed to load");
			}
			return clip;
		}

		public async Task FindAvailableAudioAsync()
		{
			if (InstanceConfig.audioLoadingOptions.Value != 0)
			{
				ClearCache();
				FileSystemUtil.ValidateAndPrepareDirectory(m_audioPath);
				await LoadAllCategoriesAsync();
				LogLoadingResults();
			}
		}

		public void UpdateAudioPath(string newAudioPath)
		{
			if (string.IsNullOrEmpty(newAudioPath))
			{
				LogManager.LogError("Cannot update with empty or null paths");
				return;
			}
			LogManager.LogInfo("Updating audio paths and reloading audio...");
			m_audioPath = newAudioPath;
		}

		public void UpdateAudioFileNames(AnnouncerJsonSetting jsonSetting)
		{
			m_jsonSetting = jsonSetting;
		}

		public void ClearCache()
		{
			ClearAudioClipCache();
			categoryFailedLoading.Clear();
		}

		private async Task LoadAllCategoriesAsync()
		{
			List<Task<(string category, List<AudioClip> clips)>> loadingTasks = new List<Task<(string, List<AudioClip>)>>();
			string[] array = audioCategories;
			foreach (string category in array)
			{
				loadingTasks.Add(LoadCategoryAsync(category).ContinueWith((Task<List<AudioClip>> task) => (category, task.Result)));
			}
			(string category, List<AudioClip> clips)[] array2 = await Task.WhenAll(loadingTasks);
			for (int j = 0; j < array2.Length; j++)
			{
				var (category2, clips) = array2[j];
				if (clips != null && clips.Count > 0)
				{
					m_audioClips[category2] = clips;
				}
			}
		}

		private async Task<List<AudioClip>> LoadCategoryAsync(string category)
		{
			if (!TryGetValidAudioFiles(category, out var validFiles))
			{
				return null;
			}
			LogManager.LogInfo($"Loading category {category} with {validFiles.Count} files");
			IEnumerable<Task<AudioClip>> clipLoadingTasks = validFiles.Select((string path) => AudioClipLoader.LoadAudioClipAsync(path));
			new List<AudioClip>();
			try
			{
				List<AudioClip> loadedClips = (await Task.WhenAll(clipLoadingTasks)).Where((AudioClip c) => (Object)(object)c != (Object)null).ToList();
				if (loadedClips.Count > 0)
				{
					LogManager.LogInfo($"Successfully loaded {loadedClips.Count}/{validFiles.Count} clips for {category}");
					return loadedClips;
				}
				LogCategoryFailure(category, "All audio files failed to load");
				return null;
			}
			catch (Exception ex)
			{
				LogCategoryFailure(category, "Exception during loading: " + ex.Message);
				return null;
			}
		}

		private void ClearAudioClipCache()
		{
			foreach (List<AudioClip> value in m_audioClips.Values)
			{
				foreach (AudioClip item in value)
				{
					if ((Object)(object)item != (Object)null)
					{
						Object.Destroy((Object)(object)item);
					}
				}
			}
			m_audioClips.Clear();
		}

		private void LogCategoryFailure(string category, string reason)
		{
			categoryFailedLoading.Add(category);
			LogManager.LogWarning("Failed to load category 「" + category + "」: " + reason);
		}

		private void LogLoadingResults()
		{
			LogForPluginConfigurator();
			if (categoryFailedLoading.Count == 0)
			{
				LogManager.LogInfo("All audio categories successfully loaded");
			}
			else
			{
				LogManager.LogWarning("Failed to load audio categories: " + string.Join(", ", categoryFailedLoading));
			}
		}

		private void LogForPluginConfigurator()
		{
			StringBuilder stringBuilder = new StringBuilder();
			string[] array = audioCategories;
			foreach (string text in array)
			{
				List<AudioClip> value;
				int num = (m_audioClips.TryGetValue(text, out value) ? value.Count : 0);
				CategoryAudioSetting value2;
				int num2 = (m_jsonSetting.CategoryAudioMap.TryGetValue(text, out value2) ? value2.AudioFiles.Count : 0);
				stringBuilder.AppendLine($"{text} ({num}/{num2})");
			}
			string obj = stringBuilder.ToString();
			OnPluginConfiguratorLogUpdated?.Invoke(obj);
		}

		private bool TryGetValidAudioFiles(string category, out List<string> validFiles)
		{
			validFiles = null;
			if (!m_jsonSetting.CategoryAudioMap.TryGetValue(category, out var value) || value.AudioFiles == null || value.AudioFiles.Count == 0)
			{
				LogCategoryFailure(category, "No file names configured");
				return false;
			}
			List<string> audioFiles = value.AudioFiles;
			validFiles = audioFiles.Select((string name) => PathManager.GetFileWithExtension(m_audioPath, name)).Where(File.Exists).ToList();
			if (validFiles.Count == 0)
			{
				LogCategoryFailure(category, "No valid files found");
				return false;
			}
			return true;
		}
	}
	public class CooldownManager
	{
		private Dictionary<string, float> m_individualCooldowns = new Dictionary<string, float>();

		public CooldownManager(string[] audioCategories)
		{
			foreach (string key in audioCategories)
			{
				m_individualCooldowns[key] = 0f;
			}
		}

		public bool IsIndividualCooldownActive(string category)
		{
			return m_individualCooldowns[category] > 0f;
		}

		public bool IsSharedCooldownActive()
		{
			return AnnouncerManager.sharedCooldown > 0f;
		}

		public void StartIndividualCooldown(string category, float duration)
		{
			((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(CooldownCoroutine(delegate(float value)
			{
				m_individualCooldowns[category] = value;
			}, duration));
		}

		public void StartSharedCooldown(float duration)
		{
			((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(CooldownCoroutine(delegate(float value)
			{
				AnnouncerManager.sharedCooldown = value;
			}, duration));
		}

		public void ResetCooldowns()
		{
			List<string> list = m_individualCooldowns.Keys.ToList();
			foreach (string item in list)
			{
				m_individualCooldowns[item] = 0f;
			}
		}

		private IEnumerator CooldownCoroutine(Action<float> setCooldown, float initialCooldown)
		{
			if (initialCooldown <= 0f)
			{
				setCooldown(0f);
				yield break;
			}
			float cooldown = initialCooldown;
			float waitTime = cooldown * 3f / 4f;
			float deltaTimeTime = cooldown * 1f / 4f;
			setCooldown(cooldown);
			yield return (object)new WaitForSeconds(waitTime);
			float timePassed = 0f;
			while (timePassed < deltaTimeTime)
			{
				timePassed += Time.deltaTime;
				cooldown -= Time.deltaTime;
				setCooldown(cooldown);
				yield return null;
			}
			setCooldown(0f);
		}
	}
	public enum ValidationState
	{
		Success,
		AudioFailedLoading,
		SharedCooldown,
		IndividualCooldown,
		DisabledByConfig,
		ClipNotFound,
		ValidationError,
		ComponentsNotInitialized,
		InvalidKey
	}
	public static class AnnouncerManager
	{
		public static Action reloadAnnouncer;

		public static Action updateAnnouncerPath;

		public static Action resetCooldown;

		public static Action clearAudioClipCache;

		public static float sharedCooldown;

		public static long playRequestId;

		public static void ReloadAllAnnouncer()
		{
			reloadAnnouncer?.Invoke();
		}

		public static void UpdateAllAnnouncerPaths()
		{
			updateAnnouncerPath?.Invoke();
		}

		public static void ResetCooldown()
		{
			sharedCooldown = 0f;
			resetCooldown?.Invoke();
		}

		public static void ClearAudioClipsCache()
		{
			clearAudioClipCache?.Invoke();
		}
	}
	public static class AudioDispatcher
	{
		public static void SendClipToAudioSource(AudioClip clip, AudioSourceSetting m_audioSourceConfig)
		{
			switch (InstanceConfig.audioPlayOptions.Value)
			{
			case 0:
				SoloAudioSource.Instance.PlayOneShot(clip, m_audioSourceConfig);
				break;
			case 1:
				AudioSourcePool.Instance.PlayOneShot(clip, m_audioSourceConfig);
				break;
			default:
				SoloAudioSource.Instance.PlayOneShot(clip, m_audioSourceConfig);
				break;
			}
		}
	}
	public static class AudioSourceManager
	{
		public static AudioSource ConfigureAudioSource(AudioSource audioSource, AudioSourceSetting config)
		{
			audioSource.spatialBlend = config.SpatialBlend;
			audioSource.priority = config.Priority;
			audioSource.volume = ((config.Volume < 1f) ? config.Volume : 1f);
			audioSource.pitch = config.Pitch;
			return audioSource;
		}

		public static AudioSource AddLowPassFilter(AudioSource audioSource)
		{
			if ((Object)(object)audioSource == (Object)null)
			{
				return null;
			}
			AudioLowPassFilter val = ((Component)audioSource).gameObject.GetComponent<AudioLowPassFilter>() ?? ((Component)audioSource).gameObject.AddComponent<AudioLowPassFilter>();
			val.cutoffFrequency = 1000f;
			val.lowpassResonanceQ = 1f;
			return audioSource;
		}

		public static AudioSource RemoveLowPassFilter(AudioSource audioSource)
		{
			if ((Object)(object)audioSource == (Object)null)
			{
				return null;
			}
			AudioLowPassFilter component = ((Component)audioSource).GetComponent<AudioLowPassFilter>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			return audioSource;
		}

		public static IEnumerator FadeVolume(AudioSource audioSource, float targetVolume, float duration)
		{
			if (!((Object)(object)audioSource == (Object)null))
			{
				float startVolume = audioSource.volume;
				float timeStep = duration / 5f;
				float time = 0f;
				while (time < duration)
				{
					audioSource.volume = Mathf.Lerp(startVolume, targetVolume, time / duration);
					time += timeStep;
					yield return (object)new WaitForSeconds(timeStep);
				}
				audioSource.volume = targetVolume;
			}
		}
	}
	public struct AudioSourceSetting
	{
		public float SpatialBlend { get; set; }

		public int Priority { get; set; }

		public float Volume { get; set; }

		public float Pitch { get; set; }

		public static AudioSourceSetting Default
		{
			get
			{
				AudioSourceSetting result = default(AudioSourceSetting);
				result.SpatialBlend = 0f;
				result.Priority = 0;
				result.Volume = 1f;
				result.Pitch = 1f;
				return result;
			}
		}
	}
	[Description("Because it's..... related so I just put it at here instead of creating a new object file")]
	public static class UnderwaterController_inWater_Instance
	{
		public static bool isInWater
		{
			get
			{
				UnderwaterController instance = MonoSingleton<UnderwaterController>.Instance;
				return (Object)(object)instance != (Object)null && instance.inWater;
			}
		}

		public static void CheckIsInWater()
		{
			if (!isInWater || !InstanceConfig.isLowPassFilterEnabled.Value)
			{
				RemoveAudioLowPassFilterFromAllAudioSource();
			}
			else if (isInWater)
			{
				AddAudioLowPassFilterToAllAudioSource();
			}
		}

		private static void RemoveAudioLowPassFilterFromAllAudioSource()
		{
			AudioSourcePool.Instance.RemoveAudioLowPassFilterFromActiveAudioSource();
			SoloAudioSource.Instance.RemoveAudioLowPassFilter();
		}

		private static void AddAudioLowPassFilterToAllAudioSource()
		{
			AudioSourcePool.Instance.AddAudioLowPassFilterToActiveAudioSource();
			SoloAudioSource.Instance.AddAudioLowPassFilter();
		}
	}
	[Description("Q : Why? A : Prevent when audio is playing and enter/out of the water")]
	[HarmonyPatch(typeof(UnderwaterController), "EnterWater")]
	public static class EnterWater_Patch
	{
		public static void Postfix()
		{
			UnderwaterController_inWater_Instance.CheckIsInWater();
		}
	}
	[HarmonyPatch(typeof(UnderwaterController), "OutWater")]
	public static class OutWater_Patch
	{
		public static void Postfix()
		{
			UnderwaterController_inWater_Instance.CheckIsInWater();
		}
	}
	public class CoroutineRunner : MonoBehaviour
	{
		private static CoroutineRunner m_instance;

		public static CoroutineRunner Instance
		{
			get
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				if ((Object)(object)m_instance == (Object)null)
				{
					GameObject val = new GameObject("CoroutineRunner");
					m_instance = val.AddComponent<CoroutineRunner>();
					Object.DontDestroyOnLoad((Object)(object)val);
				}
				return m_instance;
			}
		}
	}
	public static class FileSystemUtil
	{
		public static void ValidateAndPrepareDirectory(string directoryPath)
		{
			if (!Directory.Exists(directoryPath))
			{
				LogManager.LogWarning("Directory not found: " + directoryPath);
				Directory.CreateDirectory(directoryPath);
			}
		}
	}
	public static class JsonManager
	{
		public static T ReadJson<T>(string jsonName) where T : class
		{
			ValidateJsonName(jsonName);
			string currentPluginPath = PathManager.GetCurrentPluginPath(jsonName);
			ValidateFileExists(currentPluginPath, jsonName);
			return DeserializeJson<T>(currentPluginPath, jsonName);
		}

		public static T CreateJson<T>(string jsonName, T data) where T : class
		{
			ValidateJsonName(jsonName);
			string currentPluginPath = PathManager.GetCurrentPluginPath(jsonName);
			ValidateFileDoesNotExist(currentPluginPath, jsonName);
			return SerializeAndSaveJson(currentPluginPath, jsonName, data);
		}

		public static T WriteJson<T>(string jsonName, T data) where T : class
		{
			ValidateJsonName(jsonName);
			string currentPluginPath = PathManager.GetCurrentPluginPath(jsonName);
			ValidateFileExists(currentPluginPath, jsonName);
			return SerializeAndSaveJson(currentPluginPath, jsonName, data);
		}

		private static void ValidateJsonName(string jsonName)
		{
			if (string.IsNullOrEmpty(jsonName))
			{
				throw new ArgumentException("JSON file name cannot be null or empty");
			}
		}

		private static void ValidateFileExists(string path, string name)
		{
			if (!File.Exists(path))
			{
				throw new FileNotFoundException("JSON file '" + name + "' not found at path: " + path);
			}
		}

		private static void ValidateFileDoesNotExist(string path, string name)
		{
			if (File.Exists(path))
			{
				throw new InvalidOperationException("JSON file '" + name + "' already exists at path: " + path);
			}
		}

		private static T DeserializeJson<T>(string path, string name) where T : class
		{
			try
			{
				string text = File.ReadAllText(path);
				T val = JsonConvert.DeserializeObject<T>(text);
				if (val == null)
				{
					throw new InvalidOperationException("Failed to deserialize JSON file '" + name + "' into type " + typeof(T).Name);
				}
				return val;
			}
			catch (Exception ex)
			{
				LogManager.LogError("Error reading JSON file '" + name + "': " + ex.Message);
				throw;
			}
		}

		private static T SerializeAndSaveJson<T>(string path, string name, T data) where T : class
		{
			try
			{
				string contents = JsonConvert.SerializeObject((object)data, (Formatting)1);
				File.WriteAllText(path, contents);
				LogManager.LogInfo("Writed JSON file '" + name + "' at path: " + path);
				return data;
			}
			catch (Exception ex)
			{
				LogManager.LogError("Error writing JSON file '" + name + "': " + ex.Message);
				throw;
			}
		}
	}
	public static class LogManager
	{
		public static void LogInfo(object data)
		{
			Plugin.log.LogInfo(data);
		}

		public static void LogWarning(object data)
		{
			Plugin.log.LogWarning(data);
		}

		public static void LogError(object data)
		{
			Plugin.log.LogError(data);
		}
	}
	public static class PathManager
	{
		public static string GetCurrentPluginPath(string filePath = null)
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			return CleanPath(Path.Combine(directoryName, filePath ?? string.Empty));
		}

		public static string GetGamePath(string filePath)
		{
			string gameRootPath = Paths.GameRootPath;
			return CleanPath(Path.Combine(gameRootPath, filePath));
		}

		[Description("Reference : (因win程序员想偷懒! 竟在剪切板插入隐藏字符) https://www.bilibili.com/video/BV1ebLczjEWZ (Accessed in 24/4/2025)")]
		public static string CleanPath(string path)
		{
			if (string.IsNullOrEmpty(path))
			{
				return path;
			}
			char[] trimChars = new char[5] { '\u202a', '\u202b', '\u202c', '\u202d', '\u202e' };
			string text = path.TrimStart(trimChars);
			if (!path.Equals(text))
			{
				LogManager.LogInfo("Path cleaned: Original='" + path + "', Cleaned='" + text + "'");
			}
			return text;
		}

		[Description("Reference : (C# 判断操作系统是 Windows 还是 Linux - 青叶煮酒 - 博客园, 11/1/2022) https://www.cnblogs.com/dhqy/p/15787463.html (Accessed in 25/4/2025)")]
		public static void OpenDirectory(string path)
		{
			if (!string.IsNullOrEmpty(path) && Directory.Exists(path))
			{
				if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
				{
					Process.Start("explorer.exe", path);
				}
				else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
				{
					Process.Start("xdg-open", path);
				}
				else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
				{
					Process.Start("open", path);
				}
				else
				{
					LogManager.LogWarning("Unsupported OS platform.");
				}
			}
			else
			{
				LogManager.LogWarning("The path is not valid or the directory does not exist.");
			}
		}

		public static string GetFileWithExtension(string filePath, string fileName)
		{
			string searchPattern = fileName + ".*";
			string[] files = Directory.GetFiles(filePath, searchPattern);
			if (files.Length != 0)
			{
				return files[0];
			}
			return null;
		}
	}
	public static class ReflectionManager
	{
		public static void LoadByReflection(string assemblyName, string methodName, object[] parameter = null)
		{
			try
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				Type type = executingAssembly.GetType(assemblyName);
				type.GetMethod(methodName, BindingFlags.Static | BindingFlags.Public)?.Invoke(null, parameter);
			}
			catch (Exception arg)
			{
				LogManager.LogError($"Failed to load {assemblyName}'s {methodName} by : {arg}");
			}
		}
	}
	[BepInPlugin("greycsont.ultrakill.GreyAnnouncer", "Grey Announcer", "1.1.0")]
	[BepInProcess("ULTRAKILL.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource log;

		private Harmony m_harmony;

		private void Awake()
		{
			log = ((BaseUnityPlugin)this).Logger;
			LoadMainModule();
			LoadOptionalModule();
			PatchHarmony();
			LogManager.LogInfo("Plugin greycsont.ultrakill.GreyAnnouncer is loaded!");
		}

		private void LoadMainModule()
		{
			InstanceConfig.Initialize(this);
		}

		private void LoadOptionalModule()
		{
			CheckPluginLoaded("com.eternalUnion.pluginConfigurator", "greycsont.GreyAnnouncer.PluginConfiguratorEntry");
			RankAnnouncerV2.Initialize();
		}

		private void PatchHarmony()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			m_harmony = new Harmony("greycsont.ultrakill.GreyAnnouncer.harmony");
			m_harmony.PatchAll();
		}

		private void CheckPluginLoaded(string GUID, string assemblyName)
		{
			PluginDependencies.LoadIfPluginExists("com.eternalUnion.pluginConfigurator", "PluginConfiguratorEntry", delegate
			{
				ReflectionManager.LoadByReflection("greycsont.GreyAnnouncer.PluginConfiguratorEntry", "Initialize");
			});
		}
	}
	public static class MainPanelBuilder
	{
		private enum PlayOptions
		{
			Override,
			Parallel
		}

		private enum audioLoadingOptions
		{
			Load_then_Play,
			Preload_and_Play
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static FloatValueChangeEventDelegate <>9__8_0;

			public static FloatValueChangeEventDelegate <>9__8_1;

			public static OnValueChangeEventDelegate <>9__9_0;

			public static EnumValueChangeEventDelegate<PlayOptions> <>9__9_1;

			public static EnumValueChangeEventDelegate<audioLoadingOptions> <>9__9_2;

			public static OnClick <>9__9_3;

			public static OnClick <>9__9_4;

			public static OnClick <>9__9_5;

			public static StringValueChangeEventDelegate <>9__10_0;

			public static BoolValueChangeEventDelegate <>9__10_1;

			public static BoolValueChangeEventDelegate <>9__10_2;

			public static Action<string> <>9__12_0;

			internal void <CreateCooldownControls>b__8_0(FloatValueChangeEvent e)
			{
				InstanceConfig.sharedPlayCooldown.Value = e.value;
				AnnouncerManager.ResetCooldown();
			}

			internal void <CreateCooldownControls>b__8_1(FloatValueChangeEvent e)
			{
				InstanceConfig.individualPlayCooldown.Value = e.value;
				AnnouncerManager.ResetCooldown();
			}

			internal void <CreateAudioControls>b__9_0(FloatSliderValueChangeEvent e)
			{
				InstanceConfig.audioSourceVolume.Value = e.newValue;
				AudioSourcePool.Instance.UpdateAllActiveSourcesVolume(e.newValue);
				SoloAudioSource.Instance.UpdateSoloAudioSourceVolume(e.newValue);
			}

			internal void <CreateAudioControls>b__9_1(EnumValueChangeEvent<PlayOptions> e)
			{
				InstanceConfig.audioPlayOptions.Value = (int)e.value;
			}

			internal void <CreateAudioControls>b__9_2(EnumValueChangeEvent<audioLoadingOptions> e)
			{
				InstanceConfig.audioLoadingOptions.Value = (int)e.value;
				if (e.value.Equals(audioLoadingOptions.Load_then_Play))
				{
					LogManager.LogInfo("Clear audio clip cache");
					ClearAudioClipsCache();
				}
				if (e.value.Equals(audioLoadingOptions.Preload_and_Play))
				{
					LogManager.LogInfo("Reloading all announcer audio");
					ReloadAllAnnouncers();
				}
			}

			internal void <CreateAudioControls>b__9_3()
			{
				PathManager.OpenDirectory(InstanceConfig.audioFolderPath.Value);
			}

			internal void <CreateAudioControls>b__9_4()
			{
				ReloadAllAnnouncers();
			}

			internal void <CreateAudioControls>b__9_5()
			{
				advancedPanel.OpenPanel();
			}

			internal void <CreateAdvancedOptionPanel>b__10_0(StringValueChangeEvent e)
			{
				InstanceConfig.audioFolderPath.Value = e.value;
				AnnouncerManager.UpdateAllAnnouncerPaths();
			}

			internal void <CreateAdvancedOptionPanel>b__10_1(BoolValueChangeEvent e)
			{
				InstanceConfig.isLowPassFilterEnabled.Value = e.value;
				UnderwaterController_inWater_Instance.CheckIsInWater();
			}

			internal void <CreateAdvancedOptionPanel>b__10_2(BoolValueChangeEvent e)
			{
				InstanceConfig.isAudioRandomizationEnabled.Value = e.value;
				LogManager.LogInfo($"Switch audio randomization : {e.value}");
			}

			internal void <CreateDelegateTextFromBackEnd>b__12_0(string log)
			{
				logHeader.text = log + "\n";
			}
		}

		private static readonly Color m_greyColour = new Color(0.85f, 0.85f, 0.85f, 1f);

		private static readonly Color m_CyanColour = new Color(0f, 1f, 1f, 1f);

		private static readonly Color m_OrangeColour = new Color(1f, 0.6f, 0.2f, 1f);

		private static PluginConfigurator m_pluginConfigurator;

		public static ConfigHeader logHeader;

		private static ConfigPanel advancedPanel;

		public static void Build(PluginConfigurator config)
		{
			m_pluginConfigurator = config;
			CreateMainSettingSectionTitle();
			CreateCooldownControls();
			CreateAudioControls();
			CreateAdvancedOptionPanel();
			CreateAnnouncerSection();
			CreateDelegateTextFromBackEnd();
		}

		private static void CreateMainSettingSectionTitle()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			new ConfigSpace(m_pluginConfigurator.rootPanel, 15f);
			ConfigHeader val = new ConfigHeader(m_pluginConfigurator.rootPanel, "Main Settings", 24);
			val.textColor = m_CyanColour;
		}

		private static void CreateCooldownControls()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			FloatField val = new FloatField(m_pluginConfigurator.rootPanel, "Shared Cooldown", "sharedPlayCooldown", InstanceConfig.sharedPlayCooldown.Value, 0f, 114514f);
			val.defaultValue = InstanceConfig.DEFAULT_SHARED_PLAY_COOLDOWN;
			object obj = <>c.<>9__8_0;
			if (obj == null)
			{
				FloatValueChangeEventDelegate val2 = delegate(FloatValueChangeEvent e)
				{
					InstanceConfig.sharedPlayCooldown.Value = e.value;
					AnnouncerManager.ResetCooldown();
				};
				<>c.<>9__8_0 = val2;
				obj = (object)val2;
			}
			val.onValueChange += (FloatValueChangeEventDelegate)obj;
			FloatField val3 = new FloatField(m_pluginConfigurator.rootPanel, "Individual Cooldown", "individualPlaycooldown", InstanceConfig.individualPlayCooldown.Value, 0f, 1113f);
			val3.defaultValue = InstanceConfig.DEFAULT_INDIVIDUAL_PLAY_COOLDOWN;
			object obj2 = <>c.<>9__8_1;
			if (obj2 == null)
			{
				FloatValueChangeEventDelegate val4 = delegate(FloatValueChangeEvent e)
				{
					InstanceConfig.individualPlayCooldown.Value = e.value;
					AnnouncerManager.ResetCooldown();
				};
				<>c.<>9__8_1 = val4;
				obj2 = (object)val4;
			}
			val3.onValueChange += (FloatValueChangeEventDelegate)obj2;
		}

		private static void CreateAudioControls()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Expected O, but got Unknown
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Expected O, but got Unknown
			FloatSliderField val = new FloatSliderField(m_pluginConfigurator.rootPanel, "Audio Volume", "Audio_Volume", Tuple.Create(0f, 1f), InstanceConfig.audioSourceVolume.Value, 2);
			val.defaultValue = InstanceConfig.DEFAULT_AUDIO_SOURCE_VOLUME;
			object obj = <>c.<>9__9_0;
			if (obj == null)
			{
				OnValueChangeEventDelegate val2 = delegate(FloatSliderValueChangeEvent e)
				{
					InstanceConfig.audioSourceVolume.Value = e.newValue;
					AudioSourcePool.Instance.UpdateAllActiveSourcesVolume(e.newValue);
					SoloAudioSource.Instance.UpdateSoloAudioSourceVolume(e.newValue);
				};
				<>c.<>9__9_0 = val2;
				obj = (object)val2;
			}
			val.onValueChange += (OnValueChangeEventDelegate)obj;
			EnumField<PlayOptions> val3 = new EnumField<PlayOptions>(m_pluginConfigurator.rootPanel, "Audio Play Option", "Audio_Play_Option", (PlayOptions)InstanceConfig.audioPlayOptions.Value);
			val3.defaultValue = (PlayOptions)InstanceConfig.DEFAULT_AUDIO_PLAY_OPTIONS;
			val3.onValueChange += delegate(EnumValueChangeEvent<PlayOptions> e)
			{
				InstanceConfig.audioPlayOptions.Value = (int)e.value;
			};
			EnumField<audioLoadingOptions> val4 = new EnumField<audioLoadingOptions>(m_pluginConfigurator.rootPanel, "Audio Loading Option", "Audio_Loading_Option", (audioLoadingOptions)InstanceConfig.audioLoadingOptions.Value);
			val4.defaultValue = (audioLoadingOptions)InstanceConfig.DEFAULT_AUDIO_LOADING_OPTIONS;
			val4.onValueChange += delegate(EnumValueChangeEvent<audioLoadingOptions> e)
			{
				InstanceConfig.audioLoadingOptions.Value = (int)e.value;
				if (e.value.Equals(audioLoadingOptions.Load_then_Play))
				{
					LogManager.LogInfo("Clear audio clip cache");
					ClearAudioClipsCache();
				}
				if (e.value.Equals(audioLoadingOptions.Preload_and_Play))
				{
					LogManager.LogInfo("Reloading all announcer audio");
					ReloadAllAnnouncers();
				}
			};
			ButtonArrayField val5 = new ButtonArrayField(m_pluginConfigurator.rootPanel, "audio_button_array", 3, new float[3] { 0.4f, 0.4f, 0.2f }, new string[3] { "Open Audio Folder", "Reload", "Advance" }, 5f);
			ButtonClickEvent obj2 = val5.OnClickEventHandler(0);
			object obj3 = <>c.<>9__9_3;
			if (obj3 == null)
			{
				OnClick val6 = delegate
				{
					PathManager.OpenDirectory(InstanceConfig.audioFolderPath.Value);
				};
				<>c.<>9__9_3 = val6;
				obj3 = (object)val6;
			}
			obj2.onClick += (OnClick)obj3;
			ButtonClickEvent obj4 = val5.OnClickEventHandler(1);
			object obj5 = <>c.<>9__9_4;
			if (obj5 == null)
			{
				OnClick val7 = delegate
				{
					ReloadAllAnnouncers();
				};
				<>c.<>9__9_4 = val7;
				obj5 = (object)val7;
			}
			obj4.onClick += (OnClick)obj5;
			ButtonClickEvent obj6 = val5.OnClickEventHandler(2);
			object obj7 = <>c.<>9__9_5;
			if (obj7 == null)
			{
				OnClick val8 = delegate
				{
					advancedPanel.OpenPanel();
				};
				<>c.<>9__9_5 = val8;
				obj7 = (object)val8;
			}
			obj6.onClick += (OnClick)obj7;
		}

		private static void CreateAdvancedOptionPanel()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			advancedPanel = new ConfigPanel(m_pluginConfigurator.rootPanel, "Advanced Option", "Advanced_Option");
			((ConfigField)advancedPanel).hidden = true;
			new ConfigSpace(advancedPanel, 15f);
			StringField val = new StringField(advancedPanel, "Audio Folder Path", "Audio_Folder_Path", InstanceConfig.audioFolderPath.Value);
			val.defaultValue = InstanceConfig.DEFAULT_AUDIO_FOLDER_PATH;
			object obj = <>c.<>9__10_0;
			if (obj == null)
			{
				StringValueChangeEventDelegate val2 = delegate(StringValueChangeEvent e)
				{
					InstanceConfig.audioFolderPath.Value = e.value;
					AnnouncerManager.UpdateAllAnnouncerPaths();
				};
				<>c.<>9__10_0 = val2;
				obj = (object)val2;
			}
			val.onValueChange += (StringValueChangeEventDelegate)obj;
			BoolField val3 = new BoolField(advancedPanel, "Muffle When Under Water", "LowPassFilter_Enabled", InstanceConfig.isLowPassFilterEnabled.Value);
			val3.defaultValue = true;
			object obj2 = <>c.<>9__10_1;
			if (obj2 == null)
			{
				BoolValueChangeEventDelegate val4 = delegate(BoolValueChangeEvent e)
				{
					InstanceConfig.isLowPassFilterEnabled.Value = e.value;
					UnderwaterController_inWater_Instance.CheckIsInWater();
				};
				<>c.<>9__10_1 = val4;
				obj2 = (object)val4;
			}
			val3.onValueChange += (BoolValueChangeEventDelegate)obj2;
			BoolField val5 = new BoolField(advancedPanel, "Audio Randomlization", "Audio_Randomlization", InstanceConfig.isAudioRandomizationEnabled.Value);
			val5.defaultValue = false;
			object obj3 = <>c.<>9__10_2;
			if (obj3 == null)
			{
				BoolValueChangeEventDelegate val6 = delegate(BoolValueChangeEvent e)
				{
					InstanceConfig.isAudioRandomizationEnabled.Value = e.value;
					LogManager.LogInfo($"Switch audio randomization : {e.value}");
				};
				<>c.<>9__10_2 = val6;
				obj3 = (object)val6;
			}
			val5.onValueChange += (BoolValueChangeEventDelegate)obj3;
		}

		private static void CreateAnnouncerSection()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			new ConfigSpace(m_pluginConfigurator.rootPanel, 15f);
			ConfigHeader val = new ConfigHeader(m_pluginConfigurator.rootPanel, "Announcer Section", 24);
			val.textColor = m_OrangeColour;
			logHeader = new ConfigHeader(m_pluginConfigurator.rootPanel, "", 24);
			logHeader.tmpAnchor = (TextAlignmentOptions)257;
			logHeader.textSize = 12;
			logHeader.textColor = m_CyanColour;
		}

		private static void CreateDelegateTextFromBackEnd()
		{
			AudioLoader.OnPluginConfiguratorLogUpdated = delegate(string log)
			{
				logHeader.text = log + "\n";
			};
		}

		private static void ReloadAllAnnouncers()
		{
			logHeader.text = string.Empty;
			AnnouncerManager.ReloadAllAnnouncer();
		}

		private static void ClearAudioClipsCache()
		{
			logHeader.text = string.Empty;
			AnnouncerManager.ClearAudioClipsCache();
		}
	}
	[Description("This object is loaded via reflection from Plugin.cs")]
	public class PluginConfiguratorEntry
	{
		private static PluginConfigurator m_config;

		public static PluginConfigurator config
		{
			get
			{
				return m_config;
			}
			private set
			{
				m_config = value;
			}
		}

		public static void Initialize()
		{
			CreatePluginPages();
			MainPanelBuilder.Build(m_config);
		}

		private static void CreatePluginPages()
		{
			m_config = PluginConfigurator.Create("Grey Announcer", "greycsont.ultrakill.GreyAnnouncer");
			m_config.SetIconWithURL(PathManager.GetCurrentPluginPath("icon.png"));
		}
	}
	internal static class PluginDependencies
	{
		public const string PLUGINCONFIGURATOR_GUID = "com.eternalUnion.pluginConfigurator";

		public static void LoadIfPluginExists(string guid, string moduleName, Action loader)
		{
			if (!Chainloader.PluginInfos.ContainsKey(guid))
			{
				LogManager.LogWarning("Plugin " + guid + " not loaded, skipping " + moduleName);
				return;
			}
			try
			{
				loader?.Invoke();
				LogManager.LogInfo("Loaded optional module: " + moduleName);
			}
			catch (Exception ex)
			{
				LogManager.LogError("Exception while loading " + moduleName + ": " + ex.Message);
			}
		}
	}
	internal static class PluginInfo
	{
		public const string PLUGIN_GUID = "greycsont.ultrakill.GreyAnnouncer";

		public const string PLUGIN_NAME = "Grey Announcer";

		public const string PLUGIN_VERSION = "1.1.0";
	}
	public static class RankAnnouncerV2
	{
		private static readonly string[] m_rankCategory = new string[8] { "D", "C", "B", "A", "S", "SS", "SSS", "U" };

		private static readonly Dictionary<string, string> m_displayNameMapping = new Dictionary<string, string>
		{
			{ "D", "Destruction" },
			{ "C", "Chaotic" },
			{ "B", "Brutal" },
			{ "A", "Anarchic" },
			{ "S", "Supreme" },
			{ "SS", "SSadistic" },
			{ "SSS", "SSShitstorm" },
			{ "U", "ULTRAKILL" }
		};

		private static readonly AudioAnnouncer m_announcer = new AudioAnnouncer();

		private static readonly string m_jsonName = "RankAnnouncer.json";

		private static readonly string m_pageTitle = "Rank Announcer";

		internal static AnnouncerJsonSetting m_jsonSetting;

		public static void Initialize()
		{
			JsonInitialization();
			m_announcer.Initialize(m_rankCategory, m_jsonSetting, InstanceConfig.audioFolderPath.Value);
			SubscribeAnnouncerManager();
			PluginConfigPanelInitialization(m_pageTitle, m_jsonSetting);
		}

		public static void PlayRankSound(int rank)
		{
			if (rank < 0 || rank >= m_rankCategory.Length)
			{
				LogManager.LogError($"Invalid rank index: {rank}");
			}
			else
			{
				m_announcer.PlayAudioViaIndex(rank);
			}
		}

		private static void SubscribeAnnouncerManager()
		{
			AnnouncerManager.reloadAnnouncer = (Action)Delegate.Combine(AnnouncerManager.reloadAnnouncer, new Action(ReloadAnnouncer));
			AnnouncerManager.resetCooldown = (Action)Delegate.Combine(AnnouncerManager.resetCooldown, new Action(ResetCooldowns));
			AnnouncerManager.clearAudioClipCache = (Action)Delegate.Combine(AnnouncerManager.clearAudioClipCache, new Action(ClearAudioClipCache));
			AnnouncerManager.updateAnnouncerPath = (Action)Delegate.Combine(AnnouncerManager.updateAnnouncerPath, new Action(UpdateAudioPath));
		}

		private static void ReloadAnnouncer()
		{
			JsonInitialization();
			UpdateAnnouncerJson();
			m_announcer.ReloadAudio(m_jsonSetting);
		}

		private static void UpdateAudioPath()
		{
			m_announcer.UpdateAudioPath(InstanceConfig.audioFolderPath.Value);
		}

		private static void ResetCooldowns()
		{
			m_announcer.ResetCooldown();
		}

		private static void ClearAudioClipCache()
		{
			m_announcer.ClearAudioClipsCache();
		}

		private static void JsonInitialization()
		{
			if (!CheckDoesJsonExists())
			{
				CreateJson();
			}
			m_jsonSetting = JsonManager.ReadJson<AnnouncerJsonSetting>(m_jsonName);
		}

		private static bool CheckDoesJsonExists()
		{
			return File.Exists(PathManager.GetCurrentPluginPath(m_jsonName));
		}

		private static void CreateJson()
		{
			string value;
			Dictionary<string, CategoryAudioSetting> categoryAudioMap = m_rankCategory.ToDictionary((string cat) => cat, (string cat) => new CategoryAudioSetting
			{
				Enabled = true,
				DisplayName = (m_displayNameMapping.TryGetValue(cat, out value) ? value : cat),
				AudioFiles = new List<string> { cat }
			});
			m_jsonSetting = new AnnouncerJsonSetting
			{
				CategoryAudioMap = categoryAudioMap
			};
			JsonManager.CreateJson(m_jsonName, m_jsonSetting);
		}

		public static void UpdateJson(AnnouncerJsonSetting jsonSetting)
		{
			m_jsonSetting = jsonSetting;
			UpdateAnnouncerJson();
		}

		private static void PluginConfigPanelInitialization(string announcerName, AnnouncerJsonSetting jsonSetting)
		{
			PluginDependencies.LoadIfPluginExists("com.eternalUnion.pluginConfigurator", "RegisterRankAnnouncerPage", delegate
			{
				ReflectionManager.LoadByReflection("greycsont.GreyAnnouncer.RegisterRankAnnouncerPage", "Build", new object[2] { announcerName, jsonSetting });
			});
		}

		private static void UpdateAnnouncerJson()
		{
			m_announcer.UpdateJsonSetting(m_jsonSetting);
			JsonManager.WriteJson(m_jsonName, m_jsonSetting);
		}
	}
	public static class RegisterRankAnnouncerPage
	{
		private static PluginConfigurator m_pluginConfigurator;

		private static string m_title;

		private static readonly Color HeaderColor = new Color(0.85f, 0.85f, 0.85f, 1f);

		public static void Build(string title, AnnouncerJsonSetting announcerJsonSetting)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			m_pluginConfigurator = PluginConfiguratorEntry.config;
			m_title = title;
			ConfigPanel val = new ConfigPanel(m_pluginConfigurator.rootPanel, m_title, m_title);
			new ConfigSpace(val, 15f);
			ConfigHeader val2 = new ConfigHeader(val, m_title, 24);
			val2.textColor = HeaderColor;
			Action<BoolValueChangeEvent>[] callbacks = new Action<BoolValueChangeEvent>[1]
			{
				delegate
				{
					RankAnnouncerV2.UpdateJson(announcerJsonSetting);
					LogManager.LogInfo("Updated json setting for " + m_title);
				}
			};
			foreach (KeyValuePair<string, CategoryAudioSetting> item in announcerJsonSetting.CategoryAudioMap)
			{
				BoolField val3 = CreateBoolField(val, item.Value.DisplayName, item.Key, announcerJsonSetting, defaultValue: true, callbacks);
			}
		}

		private static BoolField CreateBoolField(ConfigPanel panel, string label, string guid, AnnouncerJsonSetting jsonSetting, bool defaultValue, Action<BoolValueChangeEvent>[] callbacks = null)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			string text = GuidPrefixAdder.AddPrefixToGUID(guid);
			BoolField val = new BoolField(panel, label, text, jsonSetting.CategoryAudioMap[guid].Enabled);
			val.defaultValue = defaultValue;
			val.onValueChange += (BoolValueChangeEventDelegate)delegate(BoolValueChangeEvent e)
			{
				if (jsonSetting.CategoryAudioMap.ContainsKey(guid))
				{
					jsonSetting.CategoryAudioMap[guid].Enabled = e.value;
				}
				if (callbacks != null)
				{
					Action<BoolValueChangeEvent>[] array = callbacks;
					for (int i = 0; i < array.Length; i++)
					{
						array[i]?.Invoke(e);
					}
				}
			};
			return val;
		}
	}
	[HarmonyPatch(typeof(StyleHUD), "AscendRank")]
	public static class StyleHUDAscendRank_Patch
	{
		private static void Postfix(StyleHUD __instance)
		{
			int rankIndex = __instance.rankIndex;
			if (rankIndex >= 0 && rankIndex <= 7)
			{
				RankAnnouncerV2.PlayRankSound(rankIndex);
			}
		}
	}
	[HarmonyPatch(typeof(StyleHUD), "ComboStart")]
	public class StyleHUDComboStart_Patch
	{
		private static void Postfix(StyleHUD __instance)
		{
			if (__instance.rankIndex == 0)
			{
				RankAnnouncerV2.PlayRankSound(0);
			}
		}
	}
	public static class InstanceConfig
	{
		public static ConfigEntry<float> sharedPlayCooldown;

		public static ConfigEntry<float> individualPlayCooldown;

		public static ConfigEntry<float> audioSourceVolume;

		public static ConfigEntry<bool> isLowPassFilterEnabled;

		public static ConfigEntry<string> audioFolderPath;

		public static ConfigEntry<int> audioPlayOptions;

		public static ConfigEntry<int> audioLoadingOptions;

		public static ConfigEntry<bool> isAudioRandomizationEnabled;

		public static readonly Dictionary<string, (string section, string name, object defaultValue, string description)> ConfigEntries = new Dictionary<string, (string, string, object, string)>
		{
			{
				"SharedRankCooldown",
				("Cooldown", "Shared_rank_play_cooldown", DEFAULT_SHARED_PLAY_COOLDOWN, "Shared rank play cooldown (in secs)")
			},
			{
				"IndividualRankCooldown",
				("Cooldown", "Individual_rank_play_cooldown", DEFAULT_INDIVIDUAL_PLAY_COOLDOWN, "Individual rank play cooldown (in secs)")
			},
			{
				"AudioSourceVolume",
				("Audio", "Audio_source_volume", DEFAULT_AUDIO_SOURCE_VOLUME, "Volume of the Announcer ( Range : 0f ~ 1f )")
			},
			{
				"LowPassFilter",
				("Audio", "Under_water_low_pass_filter_Enabled", DEFAULT_LOW_PASS_FILTER_ENABLED, "Set to true to enable muffle effect when under water")
			},
			{
				"AudioFolderPath",
				("Audio", "Audio_folder_path", DEFAULT_AUDIO_FOLDER_PATH, "Path to the audio folder")
			},
			{
				"AudioPlayOptions",
				("Audio", "Audio_Play_Option", DEFAULT_AUDIO_PLAY_OPTIONS, "0 : new audio will override the old one, 1 : audio will not effect each other")
			},
			{
				"AudioLoadingOption",
				("Audio", "Audio_Loading_Option", DEFAULT_AUDIO_LOADING_OPTIONS, "0 : load clip from file (less RAM more latency), 1 : preload clip to games (less latency more RAM)")
			},
			{
				"Randomization",
				("Advance", "Audio_Randomization", DEFAULT_AUDIO_RANDOMIZATION_ENABLED, "Set to true to enable audio randomlization of announcer (randomly selected a available audio)")
			}
		};

		private static float m_defaultSharedPlayCooldown = 0f;

		private static float m_defaultIndividualPlayCooldown = 3f;

		private static float m_defaultAudioSourceVolume = 1f;

		private static bool m_defaultLowPassFilterEnabled = true;

		private static string m_audioFolderPath;

		private static int m_defaultAudioPlayOptions = 0;

		private static int m_defaultAudioLoadingOptions = 0;

		private static bool m_defaultAudioRandomizationEnabled = false;

		public static float DEFAULT_SHARED_PLAY_COOLDOWN
		{
			get
			{
				return m_defaultSharedPlayCooldown;
			}
			private set
			{
				m_defaultSharedPlayCooldown = value;
			}
		}

		public static float DEFAULT_INDIVIDUAL_PLAY_COOLDOWN
		{
			get
			{
				return m_defaultIndividualPlayCooldown;
			}
			private set
			{
				m_defaultIndividualPlayCooldown = value;
			}
		}

		public static float DEFAULT_AUDIO_SOURCE_VOLUME
		{
			get
			{
				return m_defaultAudioSourceVolume;
			}
			private set
			{
				m_defaultAudioSourceVolume = value;
			}
		}

		public static bool DEFAULT_LOW_PASS_FILTER_ENABLED
		{
			get
			{
				return m_defaultLowPassFilterEnabled;
			}
			private set
			{
				m_defaultLowPassFilterEnabled = value;
			}
		}

		public static string DEFAULT_AUDIO_FOLDER_PATH
		{
			get
			{
				return m_audioFolderPath ?? PathManager.GetCurrentPluginPath("Audio");
			}
			private set
			{
				m_audioFolderPath = value;
			}
		}

		public static int DEFAULT_AUDIO_PLAY_OPTIONS
		{
			get
			{
				return (m_defaultAudioPlayOptions < 2) ? m_defaultAudioPlayOptions : 0;
			}
			private set
			{
				m_defaultAudioPlayOptions = value;
			}
		}

		public static int DEFAULT_AUDIO_LOADING_OPTIONS
		{
			get
			{
				return (m_defaultAudioLoadingOptions < 2) ? m_defaultAudioLoadingOptions : 0;
			}
			private set
			{
				m_defaultAudioLoadingOptions = value;
			}
		}

		public static bool DEFAULT_AUDIO_RANDOMIZATION_ENABLED
		{
			get
			{
				return m_defaultAudioRandomizationEnabled;
			}
			private set
			{
				m_defaultAudioRandomizationEnabled = value;
			}
		}

		public static void Initialize(Plugin plugin)
		{
			DEFAULT_AUDIO_FOLDER_PATH = PathManager.GetCurrentPluginPath("Audio");
			BindConfigEntryValues(plugin);
		}

		private static void BindConfigEntryValues(Plugin plugin)
		{
			foreach (KeyValuePair<string, (string, string, object, string)> configEntry in ConfigEntries)
			{
				BindConfigEntry(plugin, configEntry.Key, configEntry.Value.Item1, configEntry.Value.Item2, configEntry.Value.Item3, configEntry.Value.Item4);
			}
		}

		private static void BindConfigEntry(Plugin plugin, string key, string section, string name, object defaultValue, string description)
		{
			if (defaultValue is bool)
			{
				ConfigEntry<bool> val = ((BaseUnityPlugin)plugin).Config.Bind<bool>(section, name, (bool)defaultValue, description);
				if (name == "Under_water_low_pass_filter_Enabled")
				{
					isLowPassFilterEnabled = val;
				}
				else if (name == "Audio_Randomization")
				{
					isAudioRandomizationEnabled = val;
				}
			}
			else if (defaultValue is float)
			{
				ConfigEntry<float> val2 = ((BaseUnityPlugin)plugin).Config.Bind<float>(section, name, (float)defaultValue, description);
				switch (name)
				{
				case "Shared_rank_play_cooldown":
					sharedPlayCooldown = val2;
					break;
				case "Individual_rank_play_cooldown":
					individualPlayCooldown = val2;
					break;
				case "Audio_source_volume":
					audioSourceVolume = val2;
					break;
				}
			}
			else if (defaultValue is string)
			{
				ConfigEntry<string> val3 = ((BaseUnityPlugin)plugin).Config.Bind<string>(section, name, (string)defaultValue, description);
				if (name == "Audio_folder_path")
				{
					audioFolderPath = val3;
				}
			}
			else if (defaultValue is int)
			{
				ConfigEntry<int> val4 = ((BaseUnityPlugin)plugin).Config.Bind<int>(section, name, (int)defaultValue, description);
				if (name == "Audio_Play_Option")
				{
					audioPlayOptions = val4;
				}
				else if (name == "Audio_Loading_Option")
				{
					audioLoadingOptions = val4;
				}
			}
			else
			{
				LogManager.LogError("Unsupported type for config entry: " + key + ", Type: " + (defaultValue?.GetType()?.FullName ?? "null"));
			}
		}
	}
}