Decompiled source of Seasons v1.4.0

Seasons/Newtonsoft.Json.dll

Decompiled 3 days 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.2.27524")]
[assembly: AssemblyInformationalVersion("13.0.2+4fba53a324c445f06ee08e45a015c346000a7ef2")]
[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

Seasons/Seasons.dll

Decompiled 3 days ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
using UnityEngine.Networking;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Seasons")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyProduct("Seasons")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("076e7e5f-9182-41e5-a76b-5c051d6b3957")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: AssemblyCompany("")]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.0.0")]
[module: UnverifiableCode]
public struct HSLColor
{
	public float h;

	public float s;

	public float l;

	public float a;

	public HSLColor(float h, float s, float l, float a)
	{
		this.h = h;
		this.s = s;
		this.l = l;
		this.a = a;
	}

	public HSLColor(float h, float s, float l)
	{
		this.h = h;
		this.s = s;
		this.l = l;
		a = 1f;
	}

	public HSLColor(Color c)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		HSLColor hSLColor = FromRGBA(c);
		h = hSLColor.h;
		s = hSLColor.s;
		l = hSLColor.l;
		a = hSLColor.a;
	}

	public static HSLColor FromRGBA(Color c)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		float num = c.a;
		float num2 = Mathf.Min(Mathf.Min(c.r, c.g), c.b);
		float num3 = Mathf.Max(Mathf.Max(c.r, c.g), c.b);
		float num4 = (num2 + num3) / 2f;
		float num5;
		float num6;
		if (num2 == num3)
		{
			num5 = 0f;
			num6 = 0f;
		}
		else
		{
			float num7 = num3 - num2;
			num5 = ((num4 <= 0.5f) ? (num7 / (num3 + num2)) : (num7 / (2f - (num3 + num2))));
			num6 = 0f;
			if (c.r == num3)
			{
				num6 = (c.g - c.b) / num7;
			}
			else if (c.g == num3)
			{
				num6 = 2f + (c.b - c.r) / num7;
			}
			else if (c.b == num3)
			{
				num6 = 4f + (c.r - c.g) / num7;
			}
			num6 = Mathf.Repeat(num6 * 60f, 360f);
		}
		return new HSLColor(num6, num5, num4, num);
	}

	public Color ToRGBA()
	{
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		float num = a;
		float num2 = ((l <= 0.5f) ? (l * (1f + s)) : (l + s - l * s));
		float n = 2f * l - num2;
		float num5;
		float num4;
		float num3;
		if (s == 0f)
		{
			num5 = (num4 = (num3 = l));
		}
		else
		{
			num5 = Value(n, num2, h + 120f);
			num4 = Value(n, num2, h);
			num3 = Value(n, num2, h - 120f);
		}
		return new Color(num5, num4, num3, num);
	}

	private static float Value(float n1, float n2, float hue)
	{
		hue = Mathf.Repeat(hue, 360f);
		if (hue < 60f)
		{
			return n1 + (n2 - n1) * hue / 60f;
		}
		if (hue < 180f)
		{
			return n2;
		}
		if (hue < 240f)
		{
			return n1 + (n2 - n1) * (240f - hue) / 60f;
		}
		return n1;
	}

	public static implicit operator HSLColor(Color src)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		return FromRGBA(src);
	}

	public static implicit operator Color(HSLColor src)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		return src.ToRGBA();
	}
}
namespace Seasons
{
	internal static class CustomMusic
	{
		internal class MusicSettings
		{
			public float m_volume = 1f;

			public float m_fadeInTime = 3f;

			public bool m_alwaysFadeout = false;

			public bool m_loop = true;

			public bool m_resume = true;

			public bool m_enabled = true;

			public bool m_ambientMusic = true;
		}

		public const string subdirectory = "Custom music";

		public static readonly Dictionary<string, AudioClip> audioClips = new Dictionary<string, AudioClip>();

		public static readonly Dictionary<string, MusicSettings> clipSettings = new Dictionary<string, MusicSettings>();

		internal static void SetupConfigWatcher()
		{
			string filter = "*.*";
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(GetSubdirectory(), filter);
			fileSystemWatcher.Changed += UpdateClipOnChange;
			fileSystemWatcher.Created += UpdateClipOnChange;
			fileSystemWatcher.Renamed += UpdateClipOnChange;
			fileSystemWatcher.Deleted += UpdateClipOnChange;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
			UpdateCustomMusic();
			CheckMusicList();
			SeasonEnvironment.ClearCachedObjects();
		}

		internal static void CheckMusicList()
		{
			if (!Object.op_Implicit((Object)(object)MusicMan.instance))
			{
				return;
			}
			foreach (KeyValuePair<string, AudioClip> clip in audioClips)
			{
				(MusicMan.instance.m_music.Find((NamedMusic music) => music.m_name == clip.Key) ?? GetNewMusic(clip.Key)).m_clips = (AudioClip[])(object)new AudioClip[1] { clip.Value };
			}
		}

		private static NamedMusic GetNewMusic(string name)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			MusicSettings musicSettings = GeneralExtensions.GetValueSafe<string, MusicSettings>(clipSettings, name) ?? new MusicSettings();
			NamedMusic val = new NamedMusic
			{
				m_name = name,
				m_ambientMusic = musicSettings.m_ambientMusic,
				m_resume = musicSettings.m_resume,
				m_alwaysFadeout = musicSettings.m_alwaysFadeout,
				m_enabled = musicSettings.m_enabled,
				m_fadeInTime = musicSettings.m_fadeInTime,
				m_loop = musicSettings.m_loop,
				m_volume = musicSettings.m_volume
			};
			MusicMan.instance.m_music.Add(val);
			return val;
		}

		private static string GetSubdirectory()
		{
			string text = Path.Combine(Seasons.configDirectory, "Custom music");
			Directory.CreateDirectory(text);
			return text;
		}

		private static void UpdateCustomMusic()
		{
			string path = GetSubdirectory();
			if (!Directory.Exists(path))
			{
				return;
			}
			foreach (FileInfo item in from file in new DirectoryInfo(path).EnumerateFiles("*.*", SearchOption.AllDirectories)
				orderby file.Extension.ToLower() != ".json"
				select file)
			{
				UpdateFile(item.Name, item.FullName);
			}
		}

		private static void UpdateClipOnChange(object sender, FileSystemEventArgs eargs)
		{
			UpdateFile(eargs.Name, eargs.FullPath);
			if (eargs is RenamedEventArgs)
			{
				audioClips.Remove(Path.GetFileNameWithoutExtension((eargs as RenamedEventArgs).OldName));
			}
			CheckMusicList();
			SeasonEnvironment.ClearCachedObjects();
		}

		private static void UpdateFile(string fileName, string filePath)
		{
			if (Path.GetExtension(fileName).Equals(".json", StringComparison.OrdinalIgnoreCase))
			{
				UpdateSettings(Path.GetFileNameWithoutExtension(fileName), filePath);
			}
			else
			{
				UpdateClip(Path.GetFileNameWithoutExtension(fileName), filePath);
			}
		}

		private static void UpdateClip(string clipName, string fileName)
		{
			bool flag = audioClips.Remove(clipName);
			if (TryGetAudioClip(fileName, out var audioClip))
			{
				audioClips.Add(clipName, audioClip);
				Seasons.LogInfo("Custom music " + (flag ? "updated" : "added") + ": " + clipName);
			}
		}

		private static void UpdateSettings(string clipName, string fileName)
		{
			bool flag = clipSettings.Remove(clipName);
			if (TryGetMusicSettings(fileName, out var musicSettings))
			{
				clipSettings.Add(clipName, musicSettings);
				Seasons.LogInfo("Custom music settings " + (flag ? "updated" : "added") + ": " + clipName);
			}
		}

		internal static bool TryGetAudioClip(string path, out AudioClip audioClip)
		{
			audioClip = null;
			string text = "file:///" + path.Replace("\\", "/");
			UnityWebRequest audioClip2 = UnityWebRequestMultimedia.GetAudioClip(text, (AudioType)0);
			if (audioClip2 == null)
			{
				return false;
			}
			audioClip2.SendWebRequest();
			while (!audioClip2.isDone)
			{
			}
			if (audioClip2.error != null)
			{
				Seasons.LogWarning("Failed to load audio from " + path + ": " + audioClip2.error);
				return false;
			}
			DownloadHandler downloadHandler = audioClip2.downloadHandler;
			DownloadHandler obj = ((downloadHandler is DownloadHandlerAudioClip) ? downloadHandler : null);
			audioClip = ((obj != null) ? ((DownloadHandlerAudioClip)obj).audioClip : null);
			if (Object.op_Implicit((Object)(object)audioClip))
			{
				((Object)audioClip).name = Path.GetFileNameWithoutExtension(path);
				return true;
			}
			return false;
		}

		internal static bool TryGetMusicSettings(string path, out MusicSettings musicSettings)
		{
			musicSettings = null;
			if (!File.Exists(path))
			{
				return false;
			}
			try
			{
				musicSettings = JsonUtility.FromJson<MusicSettings>(File.ReadAllText(path));
			}
			catch (Exception ex)
			{
				Seasons.LogWarning("Error reading file (" + path + ")! Error: " + ex.Message);
				return false;
			}
			return true;
		}
	}
	internal class CustomPrefabs
	{
		[HarmonyPatch(typeof(ZNetView), "Awake")]
		public static class ZNetView_Awake_AddPrefab
		{
			[HarmonyPriority(800)]
			private static bool Prefix()
			{
				return !prefabInit;
			}
		}

		[HarmonyPatch(typeof(ZSyncTransform), "Awake")]
		public static class ZSyncTransform_Awake_AddPrefab
		{
			[HarmonyPriority(800)]
			private static bool Prefix()
			{
				return !prefabInit;
			}
		}

		[HarmonyPatch(typeof(ZSyncTransform), "OnEnable")]
		public static class ZSyncTransform_OnEnable_AddPrefab
		{
			[HarmonyPriority(800)]
			private static bool Prefix()
			{
				return !prefabInit;
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Awake")]
		public static class ItemDrop_Awake_AddPrefab
		{
			[HarmonyPriority(800)]
			private static bool Prefix()
			{
				return !prefabInit;
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Start")]
		public static class ItemDrop_Start_AddPrefab
		{
			[HarmonyPriority(800)]
			private static bool Prefix()
			{
				return !prefabInit;
			}
		}

		private const string c_rootObjectName = "_shudnalRoot";

		private const string c_rootPrefabsName = "Prefabs";

		private static GameObject rootObject;

		private static GameObject rootPrefabs;

		public static bool prefabInit;

		private static void InitRootObject()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			if ((Object)(object)rootObject == (Object)null)
			{
				rootObject = (GameObject)(((object)GameObject.Find("_shudnalRoot")) ?? ((object)new GameObject("_shudnalRoot")));
			}
			Object.DontDestroyOnLoad((Object)(object)rootObject);
			if ((Object)(object)rootPrefabs == (Object)null)
			{
				Transform obj = rootObject.transform.Find("Prefabs");
				rootPrefabs = ((obj != null) ? ((Component)obj).gameObject : null);
				if ((Object)(object)rootPrefabs == (Object)null)
				{
					rootPrefabs = new GameObject("Prefabs");
					rootPrefabs.transform.SetParent(rootObject.transform, false);
					rootPrefabs.SetActive(false);
				}
			}
		}

		internal static GameObject InitPrefabClone(GameObject prefabToClone, string prefabName)
		{
			InitRootObject();
			prefabInit = true;
			GameObject val = Object.Instantiate<GameObject>(prefabToClone, rootPrefabs.transform, false);
			prefabInit = false;
			((Object)val).name = prefabName;
			return val;
		}
	}
	internal class CustomTextures
	{
		public const string texturesSubdirectory = "Custom textures";

		public const string defaultsSubdirectory = "Defaults";

		public const string versionFileName = "version";

		public static readonly Dictionary<string, Dictionary<Seasons.Season, Dictionary<int, Texture2D>>> textures = new Dictionary<string, Dictionary<Seasons.Season, Dictionary<int, Texture2D>>>();

		public static Dictionary<string, Tuple<Seasons.Season, int>> seasonVariantsFileNames;

		public static void SetupConfigWatcher()
		{
			string filter = "*.png";
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(GetSubdirectory(), filter);
			fileSystemWatcher.Changed += UpdateTexturesOnChange;
			fileSystemWatcher.Created += UpdateTexturesOnChange;
			fileSystemWatcher.Renamed += UpdateTexturesOnChange;
			fileSystemWatcher.Deleted += UpdateTexturesOnChange;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
			UpdateTexturesOnChange();
		}

		public static void UpdateTexturesOnChange(object sender = null, FileSystemEventArgs eargs = null)
		{
			UpdateTextures();
			PrefabVariantController.UpdatePrefabColors();
			ClutterVariantController.Instance?.UpdateColors();
		}

		public static void UpdateTextures()
		{
			foreach (KeyValuePair<string, Dictionary<Seasons.Season, Dictionary<int, Texture2D>>> texture in textures)
			{
				foreach (KeyValuePair<Seasons.Season, Dictionary<int, Texture2D>> item in texture.Value)
				{
					foreach (KeyValuePair<int, Texture2D> item2 in item.Value)
					{
						Object.Destroy((Object)(object)item2.Value);
					}
				}
			}
			textures.Clear();
			if (Seasons.customTextures.Value)
			{
				LoadCustomTextures(GetDefaultsSubdirectory());
				LoadCustomTextures(GetSubdirectory());
				if (textures.Count > 0)
				{
					Seasons.LogInfo($"Loaded {textures.Count} custom textures.");
				}
			}
		}

		public static bool HaveCustomTexture(string textureName, Seasons.Season season, int variant, TextureProperties properties, out Texture2D texture)
		{
			texture = null;
			if (textureName == null)
			{
				return false;
			}
			Dictionary<Seasons.Season, Dictionary<int, Texture2D>> value;
			Dictionary<int, Texture2D> value2;
			bool flag = textures.TryGetValue(textureName, out value) && value.TryGetValue(season, out value2) && value2.TryGetValue(variant, out texture);
			if (flag && (Object)(object)texture != (Object)null && ((Texture)texture).isReadable)
			{
				Color32[] pixels = texture.GetPixels32();
				if (pixels.Length != properties.width * properties.height)
				{
					properties.width = ((Texture)texture).width;
					properties.height = ((Texture)texture).height;
				}
				Object.Destroy((Object)(object)texture);
				texture = properties.CreateTexture();
				texture.SetPixels32(pixels);
				texture.Apply(true, true);
				textures[textureName][season][variant] = texture;
			}
			return flag && (Object)(object)texture != (Object)null && ((Texture)texture).isReadable;
		}

		public static void LoadCustomTextures(string path)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			if (!Directory.Exists(path))
			{
				return;
			}
			DirectoryInfo[] directories = new DirectoryInfo(path).GetDirectories();
			foreach (DirectoryInfo directoryInfo in directories)
			{
				if (directoryInfo.Name == "version" || directoryInfo.Name == "Defaults")
				{
					continue;
				}
				string name = directoryInfo.Name;
				textures.Remove(name);
				FileInfo[] files = directoryInfo.GetFiles();
				foreach (FileInfo fileInfo in files)
				{
					if (!TryGetSeasonVariant(fileInfo.Name, out var season, out var variant))
					{
						continue;
					}
					Texture2D val = new Texture2D(2, 2);
					if (!ImageConversion.LoadImage(val, File.ReadAllBytes(fileInfo.FullName)))
					{
						Object.Destroy((Object)(object)val);
						continue;
					}
					((Object)val).name = name;
					if (!textures.ContainsKey(name))
					{
						textures.Add(name, new Dictionary<Seasons.Season, Dictionary<int, Texture2D>>());
					}
					if (!textures[name].ContainsKey(season))
					{
						textures[name].Add(season, new Dictionary<int, Texture2D>());
					}
					textures[name][season][variant] = val;
				}
			}
		}

		public static void SaveDefaults()
		{
			string text = GetDefaultsSubdirectory();
			if (Directory.Exists(text))
			{
				string text2 = Directory.GetFiles(text, "version").FirstOrDefault();
				if (text2 != null && File.ReadAllText(text2) == "1.4.0")
				{
					return;
				}
				Directory.Delete(text, recursive: true);
			}
			Directory.CreateDirectory(text);
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string separator = ".Textures.";
			foreach (string item in from str in executingAssembly.GetManifestResourceNames()
				where str.IndexOf(separator) != -1
				select str)
			{
				string text3 = item.Substring(item.IndexOf(separator) + separator.Length);
				int num = text3.IndexOf('.');
				if (num != -1)
				{
					string path = text3.Substring(0, num);
					string text4 = text3.Substring(num + 1);
					if (TryGetSeasonVariant(text4, out var _, out var _))
					{
						Stream manifestResourceStream = executingAssembly.GetManifestResourceStream(item);
						byte[] array = new byte[manifestResourceStream.Length];
						manifestResourceStream.Read(array, 0, array.Length);
						File.WriteAllBytes(Path.Combine(Directory.CreateDirectory(Path.Combine(text, path)).FullName, text4), array);
					}
				}
			}
			File.WriteAllText(Path.Combine(text, "version"), "1.4.0");
		}

		public static string GetSubdirectory()
		{
			string text = Path.Combine(Seasons.configDirectory, "Custom textures");
			Directory.CreateDirectory(text);
			return text;
		}

		public static string GetDefaultsSubdirectory()
		{
			return Path.Combine(GetSubdirectory(), "Defaults");
		}

		public static bool TryGetSeasonVariant(string filename, out Seasons.Season season, out int variant)
		{
			if (seasonVariantsFileNames == null)
			{
				seasonVariantsFileNames = new Dictionary<string, Tuple<Seasons.Season, int>>();
				foreach (Seasons.Season value in Enum.GetValues(typeof(Seasons.Season)))
				{
					for (int i = 0; i < 4; i++)
					{
						seasonVariantsFileNames[CachedData.SeasonFileName(value, i)] = Tuple.Create(value, i);
					}
				}
			}
			season = Seasons.Season.Spring;
			variant = 0;
			if (!seasonVariantsFileNames.ContainsKey(filename))
			{
				return false;
			}
			season = seasonVariantsFileNames[filename].Item1;
			variant = seasonVariantsFileNames[filename].Item2;
			return true;
		}
	}
	internal static class CustomSyncedValuesSynchronizer
	{
		private static readonly Queue<IEnumerator> coroutines = new Queue<IEnumerator>();

		private static readonly WaitWhile waitForServerUpdate = new WaitWhile((Func<bool>)(() => ConfigSync.ProcessingServerUpdate));

		public static void AssignValueSafe<T>(this CustomSyncedValue<T> syncedValue, T value)
		{
			AddToQueue(AssignAfterServerUpdate(syncedValue, value, assignIfChanged: false));
		}

		public static void AssignValueSafe<T>(this CustomSyncedValue<T> syncedValue, Func<T> function)
		{
			AddToQueue(AssignAfterServerUpdate(syncedValue, function, assignIfChanged: false));
		}

		public static void AssignValueIfChanged<T>(this CustomSyncedValue<T> syncedValue, T value)
		{
			AddToQueue(AssignAfterServerUpdate(syncedValue, value, assignIfChanged: true));
		}

		public static void AssignValueIfChanged<T>(this CustomSyncedValue<T> syncedValue, Func<T> function)
		{
			AddToQueue(AssignAfterServerUpdate(syncedValue, function, assignIfChanged: true));
		}

		private static IEnumerator AssignAfterServerUpdate<T>(CustomSyncedValue<T> syncedValue, Func<T> function, bool assignIfChanged)
		{
			yield return AssignAfterServerUpdate(syncedValue, function(), assignIfChanged);
		}

		private static IEnumerator AssignAfterServerUpdate<T>(CustomSyncedValue<T> syncedValue, T value, bool assignIfChanged)
		{
			if (!assignIfChanged || !syncedValue.Value.Equals(value))
			{
				yield return waitForServerUpdate;
				syncedValue.AssignLocalValue(value);
			}
		}

		private static void AddToQueue(IEnumerator coroutine)
		{
			coroutines.Enqueue(coroutine);
			if (coroutines.Count == 1)
			{
				((MonoBehaviour)Seasons.instance).StartCoroutine(CoroutineCoordinator());
			}
		}

		private static IEnumerator CoroutineCoordinator()
		{
			while (true)
			{
				if (coroutines.Count > 0)
				{
					yield return ((MonoBehaviour)Seasons.instance).StartCoroutine(coroutines.Peek());
					coroutines.Dequeue();
				}
				else if (coroutines.Count == 0)
				{
					break;
				}
			}
		}
	}
	public class IceFloeClimb : MonoBehaviour, Hoverable, Interactable
	{
		public float m_useDistance = 3f;

		public float m_radius = 4f;

		public bool Interact(Humanoid character, bool hold, bool alt)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (hold)
			{
				return false;
			}
			if (!InUseDistance(character))
			{
				return false;
			}
			((Component)character).transform.position = Vector3.Lerp(((Component)character).transform.position, ((Component)this).transform.position, 0.35f) + Vector3.up;
			Physics.SyncTransforms();
			return false;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return false;
		}

		public string GetHoverText()
		{
			if (!InUseDistance((Humanoid)(object)Player.m_localPlayer))
			{
				return "";
			}
			return Localization.instance.Localize("[<color=yellow><b>$KEY_Use</b></color>] $piece_use");
		}

		public string GetHoverName()
		{
			return "";
		}

		public bool InUseDistance(Humanoid human)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (((Component)this).transform.position.y - ((Component)human).transform.position.y < 0.5f)
			{
				return false;
			}
			float num = Vector3.Distance(((Component)human).transform.position, ((Component)this).transform.position) / Mathf.Max(((Component)this).transform.localScale.x, ((Component)this).transform.localScale.z);
			return m_radius < num && num < m_radius + m_useDistance;
		}
	}
	public class MinimapVariantController : MonoBehaviour
	{
		private Minimap m_minimap;

		private static MinimapVariantController m_instance;

		private bool m_initialized = false;

		private Color32[] m_mapTexture;

		private Color32[] m_mapWinterTexture;

		private Texture2D m_forestTex;

		public static MinimapVariantController instance => m_instance;

		private void Awake()
		{
			m_instance = this;
			m_minimap = Minimap.instance;
		}

		private void Start()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			Texture texture = m_minimap.m_mapLargeShader.GetTexture("_ForestTex");
			m_forestTex = new Texture2D(texture.width, texture.height, texture.graphicsFormat, (TextureCreationFlags)0);
			Graphics.CopyTexture(texture, (Texture)(object)m_forestTex);
			((MonoBehaviour)this).StartCoroutine(GenerateWinterWorldMap());
		}

		private void OnDestroy()
		{
			RevertTextures();
			m_instance = null;
		}

		public void RevertTextures()
		{
			if (m_initialized)
			{
				SetMapTextures(winter: false, m_forestTex);
			}
		}

		public void UpdateColors()
		{
			if (m_initialized)
			{
				if (!Seasons.controlMinimap.Value)
				{
					RevertTextures();
					return;
				}
				Seasons.Season currentSeason = Seasons.seasonState.GetCurrentSeason();
				SetMapTextures(currentSeason == Seasons.Season.Winter, GetSeasonalForestTex(currentSeason));
			}
		}

		public Texture2D GetSeasonalForestTex(Seasons.Season season)
		{
			if (1 == 0)
			{
			}
			Texture2D result = (Texture2D)(season switch
			{
				Seasons.Season.Spring => m_forestTex, 
				Seasons.Season.Summer => Seasons.Minimap_Summer_ForestTex, 
				Seasons.Season.Fall => Seasons.Minimap_Fall_ForestTex, 
				Seasons.Season.Winter => Seasons.Minimap_Winter_ForestTex, 
				_ => m_forestTex, 
			});
			if (1 == 0)
			{
			}
			return result;
		}

		private void SetMapTextures(bool winter, Texture2D forestTex)
		{
			m_minimap.m_mapTexture.SetPixels32(winter ? m_mapWinterTexture : m_mapTexture);
			m_minimap.m_mapTexture.Apply();
			m_minimap.m_mapLargeShader.SetTexture("_ForestTex", (Texture)(object)forestTex);
			m_minimap.m_mapSmallShader.SetTexture("_ForestTex", (Texture)(object)forestTex);
		}

		public IEnumerator GenerateWinterWorldMap()
		{
			int num = m_minimap.m_textureSize / 2;
			float num2 = m_minimap.m_pixelSize / 2f;
			m_mapWinterTexture = (Color32[])(object)new Color32[m_minimap.m_textureSize * m_minimap.m_textureSize];
			m_mapTexture = (Color32[])(object)new Color32[m_minimap.m_textureSize * m_minimap.m_textureSize];
			yield return (object)new WaitUntil((Func<bool>)(() => WorldGenerator.instance != null));
			Stopwatch stopwatch = Stopwatch.StartNew();
			Thread internalThread = new Thread((ThreadStart)delegate
			{
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				for (int i = 0; i < m_minimap.m_textureSize; i++)
				{
					for (int j = 0; j < m_minimap.m_textureSize; j++)
					{
						float num3 = (float)(j - num) * m_minimap.m_pixelSize + num2;
						float num4 = (float)(i - num) * m_minimap.m_pixelSize + num2;
						Biome biome = WorldGenerator.instance.GetBiome(num3, num4, 0.02f, false);
						m_mapWinterTexture[i * m_minimap.m_textureSize + j] = Color32.op_Implicit(GetWinterPixelColor(biome));
						m_mapTexture[i * m_minimap.m_textureSize + j] = Color32.op_Implicit(Minimap.instance.GetPixelColor(biome));
					}
				}
			});
			internalThread.Start();
			yield return (object)new WaitWhile((Func<bool>)(() => internalThread.IsAlive));
			m_initialized = true;
			Seasons.LogInfo($"Minimap variant controller initialized in {stopwatch.Elapsed.TotalSeconds,-4:F2} seconds");
			UpdateColors();
		}

		public static Color GetWinterPixelColor(Biome biome)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (SeasonState.seasonBiomeSettings.SeasonalWinterMapColors.TryGetValue(biome, out var value))
			{
				return value;
			}
			return Object.op_Implicit((Object)(object)Minimap.instance) ? Minimap.instance.GetPixelColor(biome) : Color.white;
		}
	}
	[HarmonyPatch(typeof(Minimap), "Start")]
	public static class Minimap_Start_MinimapContollerInit
	{
		[HarmonyPriority(0)]
		private static void Postfix(Minimap __instance)
		{
			if (Seasons.UseTextureControllers())
			{
				((Component)((Component)__instance).transform).gameObject.AddComponent<MinimapVariantController>();
			}
		}
	}
	[HarmonyPatch(typeof(Minimap), "GenerateWorldMap")]
	public static class Minimap_GenerateWorldMap_MinimapContollerInit
	{
		private static void Postfix()
		{
			if (Seasons.UseTextureControllers())
			{
				MinimapVariantController.instance.UpdateColors();
			}
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "Start")]
	public static class ZoneSystem_Start_SeasonsCache
	{
		private static void Postfix(ZoneSystem __instance)
		{
			SeasonalTexturePrefabCache.SetupConfigWatcher();
			SeasonalTexturePrefabCache.SaveDefaults();
			CustomTextures.SaveDefaults();
			if (Seasons.UseTextureControllers())
			{
				ClutterVariantController.AddSeasonalClutter();
				if (Seasons.texturesVariants.Initialize())
				{
					((Component)__instance).gameObject.AddComponent<PrefabVariantController>();
					PrefabVariantController.AddControllerToPrefabs();
					ClutterVariantController.Initialize();
					((Component)__instance).gameObject.AddComponent<ZoneSystemVariantController>().Initialize(__instance);
					Seasons.FillListsToControl();
					Seasons.InvalidatePositionsCache();
					CustomTextures.SetupConfigWatcher();
					CustomMusic.SetupConfigWatcher();
				}
				else
				{
					Seasons.LogInfo("Missing textures variants");
				}
			}
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "OnDestroy")]
	public static class ZoneSystem_OnDestroy_SeasonsCache
	{
		private static void Postfix()
		{
			if (Seasons.UseTextureControllers())
			{
				Seasons.texturesVariants = new SeasonalTextureVariants();
			}
		}
	}
	[Serializable]
	public class TextureProperties
	{
		public TextureFormat format = (TextureFormat)5;

		public int mipmapCount = 1;

		public TextureWrapMode wrapMode = (TextureWrapMode)0;

		public FilterMode filterMode = (FilterMode)0;

		public int anisoLevel = 1;

		public float mipMapBias = 0f;

		public int width = 2;

		public int height = 2;

		public TextureProperties(Texture2D tex)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			mipmapCount = ((Texture)tex).mipmapCount;
			wrapMode = ((Texture)tex).wrapMode;
			filterMode = ((Texture)tex).filterMode;
			anisoLevel = ((Texture)tex).anisoLevel;
			mipMapBias = ((Texture)tex).mipMapBias;
			width = ((Texture)tex).width;
			height = ((Texture)tex).height;
		}

		public Texture2D CreateTexture()
		{
			//IL_000e: 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)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			return new Texture2D(width, height, format, mipmapCount, false)
			{
				filterMode = filterMode,
				anisoLevel = anisoLevel,
				mipMapBias = mipMapBias,
				wrapMode = wrapMode
			};
		}
	}
	[Serializable]
	public class PrefabController
	{
		[Serializable]
		public class CachedMaterial
		{
			public string name = string.Empty;

			public string shaderName = string.Empty;

			public Dictionary<string, int> textureProperties = new Dictionary<string, int>();

			public Dictionary<string, string[]> colorVariants = new Dictionary<string, string[]>();

			public CachedMaterial()
			{
			}

			public CachedMaterial(string materialName, string shader, string propertyName, int textureID)
			{
				name = materialName;
				shaderName = shader;
				AddTexture(propertyName, textureID);
			}

			public CachedMaterial(string materialName, string shader, string propertyName, Color[] colors)
			{
				name = materialName;
				shaderName = shader;
				AddColors(propertyName, colors);
			}

			public void AddTexture(string propertyName, int textureID)
			{
				if (!textureProperties.ContainsKey(propertyName))
				{
					textureProperties.Add(propertyName, textureID);
				}
			}

			public void AddColors(string propertyName, Color[] colors)
			{
				List<string> vec = new List<string>();
				CollectionExtensions.Do<Color>((IEnumerable<Color>)colors, (Action<Color>)delegate(Color x)
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					vec.Add("#" + ColorUtility.ToHtmlStringRGBA(x));
				});
				if (!colorVariants.ContainsKey(propertyName))
				{
					colorVariants.Add(propertyName, vec.ToArray());
				}
			}
		}

		[Serializable]
		public class CachedRenderer
		{
			public string name = string.Empty;

			public string type = string.Empty;

			public Dictionary<string, CachedMaterial> materials = new Dictionary<string, CachedMaterial>();

			public CachedRenderer()
			{
			}

			public CachedRenderer(string rendererName, string rendererType)
			{
				name = rendererName;
				type = rendererType;
			}

			public bool Initialized()
			{
				return materials.Any((KeyValuePair<string, CachedMaterial> m) => m.Value.textureProperties.Count > 0 || m.Value.colorVariants.Count > 0);
			}

			public void AddMaterialTexture(Material material, string propertyName, int textureID)
			{
				if (!materials.TryGetValue(((Object)material).name, out var value))
				{
					materials.Add(((Object)material).name, new CachedMaterial(((Object)material).name, ((Object)material.shader).name, propertyName, textureID));
				}
				else
				{
					value.AddTexture(propertyName, textureID);
				}
			}

			public void AddMaterialColors(Material material, string propertyName, Color[] colors)
			{
				if (!materials.TryGetValue(((Object)material).name, out var value))
				{
					materials.Add(((Object)material).name, new CachedMaterial(((Object)material).name, ((Object)material.shader).name, propertyName, colors));
				}
				else
				{
					value.AddColors(propertyName, colors);
				}
			}
		}

		public Dictionary<string, Dictionary<int, List<CachedRenderer>>> lodsInHierarchy = new Dictionary<string, Dictionary<int, List<CachedRenderer>>>();

		public Dictionary<int, List<CachedRenderer>> lodLevelMaterials = new Dictionary<int, List<CachedRenderer>>();

		public Dictionary<string, CachedRenderer> renderersInHierarchy = new Dictionary<string, CachedRenderer>();

		public CachedRenderer cachedRenderer;

		public Dictionary<string, string[]> particleSystemStartColors;

		public bool Initialized()
		{
			return lodsInHierarchy.Count > 0 || lodLevelMaterials.Count > 0 || renderersInHierarchy.Count > 0 || cachedRenderer != null || particleSystemStartColors != null;
		}

		public override string ToString()
		{
			return ((cachedRenderer == null) ? "" : " 1 main renderer") + ((particleSystemStartColors == null) ? "" : " 1 particles start color") + " " + ((lodsInHierarchy.Count > 0) ? $" {lodsInHierarchy.Count} LOD groups" : "") + ((lodLevelMaterials.Count > 0) ? $" {lodLevelMaterials.Count} LODs" : "") + ((renderersInHierarchy.Count > 0) ? $" {renderersInHierarchy.Count} renderersInHierarchy" : "");
		}
	}
	[Serializable]
	public class CachedData
	{
		[Serializable]
		public class TextureData
		{
			public string name;

			public byte[] originalPNG;

			public TextureProperties properties;

			public Dictionary<Seasons.Season, Dictionary<int, byte[]>> variants = new Dictionary<Seasons.Season, Dictionary<int, byte[]>>();

			public bool Initialized()
			{
				return variants.Any((KeyValuePair<Seasons.Season, Dictionary<int, byte[]>> variant) => variant.Value.Count > 0);
			}

			public TextureData(TextureVariants textureVariants)
			{
				if (textureVariants == null)
				{
					return;
				}
				originalPNG = textureVariants.originalPNG;
				name = textureVariants.originalName;
				properties = textureVariants.properties;
				foreach (KeyValuePair<Seasons.Season, Dictionary<int, Texture2D>> season in textureVariants.seasons)
				{
					variants.Add(season.Key, new Dictionary<int, byte[]>());
					foreach (KeyValuePair<int, Texture2D> item in season.Value)
					{
						variants[season.Key].Add(item.Key, ImageConversion.EncodeToPNG(item.Value));
					}
				}
			}

			public TextureData(DirectoryInfo texDirectory)
			{
				FileInfo[] files = texDirectory.GetFiles("properties.json");
				if (files.Length != 0)
				{
					properties = JsonUtility.FromJson<TextureProperties>(File.ReadAllText(files[0].FullName));
				}
				foreach (Seasons.Season value in Enum.GetValues(typeof(Seasons.Season)))
				{
					variants.Add(value, new Dictionary<int, byte[]>());
					for (int i = 0; i < 4; i++)
					{
						FileInfo[] files2 = texDirectory.GetFiles(SeasonFileName(value, i));
						if (files2.Length != 0)
						{
							variants[value].Add(i, File.ReadAllBytes(files2[0].FullName));
						}
					}
				}
			}
		}

		internal const string cacheSubdirectory = "Cache";

		internal const string prefabCacheCommonFile = "cache.bin";

		internal const string prefabCacheFileName = "cache.json";

		internal const string texturesDirectory = "textures";

		internal const string originalPostfix = ".orig.png";

		internal const string texturePropertiesFileName = "properties.json";

		public Dictionary<string, PrefabController> controllers = new Dictionary<string, PrefabController>();

		public Dictionary<int, TextureData> textures = new Dictionary<int, TextureData>();

		public uint revision = 0u;

		public CachedData(uint revision)
		{
			this.revision = revision;
		}

		public bool Initialized()
		{
			return controllers.Count > 0 && textures.Count > 0;
		}

		public void SaveOnDisk()
		{
			if (Initialized())
			{
				if (Seasons.cacheStorageFormat.Value == Seasons.CacheFormat.Binary)
				{
					SaveToBinary();
					return;
				}
				if (Seasons.cacheStorageFormat.Value == Seasons.CacheFormat.Json)
				{
					SaveToJSON();
					return;
				}
				SaveToJSON();
				SaveToBinary();
			}
		}

		public void LoadFromDisk()
		{
			if (Seasons.cacheStorageFormat.Value == Seasons.CacheFormat.Json)
			{
				LoadFromJSON();
			}
			else
			{
				LoadFromBinary();
			}
		}

		private void SaveToJSON()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			string text = CacheDirectory();
			Directory.CreateDirectory(text);
			string text2 = Path.Combine(text, "cache.json");
			File.WriteAllText(text2, JsonConvert.SerializeObject((object)controllers, (Formatting)1, new JsonSerializerSettings
			{
				NullValueHandling = (NullValueHandling)1,
				DefaultValueHandling = (DefaultValueHandling)1
			}));
			string text3 = Path.Combine(text, "textures");
			Seasons.LogInfo("Saved cache file " + text2);
			foreach (KeyValuePair<int, TextureData> texture in textures)
			{
				string text4 = Path.Combine(text3, texture.Key.ToString());
				Directory.CreateDirectory(text4);
				File.WriteAllBytes(Path.Combine(text4, texture.Value.name + ".orig.png"), texture.Value.originalPNG);
				File.WriteAllText(Path.Combine(text4, "properties.json"), JsonUtility.ToJson((object)texture.Value.properties, true));
				foreach (KeyValuePair<Seasons.Season, Dictionary<int, byte[]>> variant in texture.Value.variants)
				{
					foreach (KeyValuePair<int, byte[]> item in variant.Value)
					{
						File.WriteAllBytes(Path.Combine(text4, SeasonFileName(variant.Key, item.Key)), item.Value);
					}
				}
			}
			Seasons.LogInfo($"Saved {textures.Count} textures at {text3}");
		}

		private void LoadFromJSON()
		{
			string text = CacheDirectory();
			DirectoryInfo directoryInfo = new DirectoryInfo(text);
			if (!directoryInfo.Exists)
			{
				return;
			}
			FileInfo[] files = directoryInfo.GetFiles("cache.json");
			if (files.Length == 0)
			{
				Seasons.LogInfo("File not found: " + Path.Combine(text, "cache.json"));
				return;
			}
			try
			{
				controllers = JsonConvert.DeserializeObject<Dictionary<string, PrefabController>>(File.ReadAllText(files[0].FullName));
			}
			catch (Exception arg)
			{
				Seasons.LogWarning($"Error loading JSON cache data from {files[0].FullName}\n{arg}");
				return;
			}
			DirectoryInfo[] directories = directoryInfo.GetDirectories("textures");
			if (directories.Length == 0)
			{
				return;
			}
			DirectoryInfo[] directories2 = directories[0].GetDirectories();
			foreach (DirectoryInfo directoryInfo2 in directories2)
			{
				int key = int.Parse(directoryInfo2.Name);
				if (!textures.ContainsKey(key))
				{
					TextureData textureData = new TextureData(directoryInfo2);
					if (textureData.Initialized())
					{
						textures.Add(key, textureData);
					}
				}
			}
		}

		private void SaveToBinary()
		{
			string text = CacheDirectory();
			Directory.CreateDirectory(text);
			using (FileStream fileStream = new FileStream(Path.Combine(text, "cache.bin"), FileMode.Create))
			{
				BinaryFormatter binaryFormatter = new BinaryFormatter();
				binaryFormatter.Serialize(fileStream, this);
				fileStream.Dispose();
			}
			Seasons.LogInfo("Saved cache file " + Path.Combine(text, "cache.bin"));
		}

		private void LoadFromBinary()
		{
			string path = CacheDirectory();
			string text = Path.Combine(path, "cache.bin");
			if (!File.Exists(text))
			{
				Seasons.LogInfo("File not found: " + text);
				return;
			}
			try
			{
				using FileStream fileStream = new FileStream(text, FileMode.Open, FileAccess.Read, FileShare.Read);
				BinaryFormatter binaryFormatter = new BinaryFormatter();
				CachedData cachedData = (CachedData)binaryFormatter.Deserialize(fileStream);
				fileStream.Dispose();
				DictionaryExt.Copy<string, PrefabController>(controllers, cachedData.controllers);
				DictionaryExt.Copy<int, TextureData>(textures, cachedData.textures);
				cachedData = null;
			}
			catch (Exception arg)
			{
				Seasons.LogWarning($"Error loading binary cache data from {text}:\n {arg}");
			}
		}

		public string CacheDirectory()
		{
			return Path.Combine(Seasons.cacheDirectory, revision.ToString());
		}

		public static string SeasonFileName(Seasons.Season season, int variant)
		{
			return $"{season}_{variant + 1}.png";
		}
	}
	public class TextureVariants
	{
		public Texture2D original;

		public string originalName;

		public byte[] originalPNG;

		public TextureProperties properties;

		public Dictionary<Seasons.Season, Dictionary<int, Texture2D>> seasons = new Dictionary<Seasons.Season, Dictionary<int, Texture2D>>();

		public TextureVariants(CachedData.TextureData texData)
		{
			if (texData == null)
			{
				return;
			}
			properties = texData.properties;
			foreach (Seasons.Season value3 in Enum.GetValues(typeof(Seasons.Season)))
			{
				if (!texData.variants.TryGetValue(value3, out var value))
				{
					continue;
				}
				for (int i = 0; i < 4; i++)
				{
					if (value.TryGetValue(i, out var value2))
					{
						Texture2D val = properties.CreateTexture();
						if (ImageConversion.LoadImage(val, value2, true))
						{
							AddVariant(value3, i, val);
						}
						else
						{
							Object.Destroy((Object)(object)val);
						}
					}
				}
			}
		}

		public TextureVariants(Texture texture)
		{
			SetOriginalTexture(texture);
		}

		public void SetOriginalTexture(Texture texture)
		{
			original = (Texture2D)(object)((texture is Texture2D) ? texture : null);
			properties = new TextureProperties((Texture2D)(object)((texture is Texture2D) ? texture : null));
			originalName = ((Object)original).name;
		}

		public bool Initialized()
		{
			return seasons.Any((KeyValuePair<Seasons.Season, Dictionary<int, Texture2D>> season) => season.Value.Count > 0);
		}

		public bool HaveOriginalTexture()
		{
			return Object.op_Implicit((Object)(object)original);
		}

		public void ApplyTextures()
		{
			foreach (KeyValuePair<Seasons.Season, Dictionary<int, Texture2D>> season in seasons)
			{
				foreach (KeyValuePair<int, Texture2D> item in season.Value)
				{
					item.Value.Apply(true, true);
				}
			}
		}

		public void AddVariant(Seasons.Season season, int variant, Texture2D tex)
		{
			if (!seasons.TryGetValue(season, out var value))
			{
				value = new Dictionary<int, Texture2D>();
				seasons.Add(season, value);
			}
			if (!value.ContainsKey(variant))
			{
				value.Add(variant, tex);
			}
		}
	}
	public class SeasonalTextureVariants
	{
		public Dictionary<string, PrefabController> controllers = new Dictionary<string, PrefabController>();

		public Dictionary<int, TextureVariants> textures = new Dictionary<int, TextureVariants>();

		public uint revision = 0u;

		public bool Initialize(bool force = false)
		{
			if (!force && Initialized())
			{
				return true;
			}
			controllers.Clear();
			textures.Clear();
			revision = SeasonalTexturePrefabCache.GetRevision();
			CachedData cachedData = new CachedData(revision);
			if (force && Directory.Exists(cachedData.CacheDirectory()))
			{
				Directory.Delete(cachedData.CacheDirectory(), recursive: true);
			}
			cachedData.LoadFromDisk();
			if (cachedData.Initialized())
			{
				DictionaryExt.Copy<string, PrefabController>(controllers, cachedData.controllers);
				foreach (KeyValuePair<int, CachedData.TextureData> texture in cachedData.textures)
				{
					if (!textures.ContainsKey(texture.Key))
					{
						TextureVariants textureVariants = new TextureVariants(texture.Value);
						if (textureVariants.Initialized())
						{
							textures.Add(texture.Key, textureVariants);
						}
					}
				}
				Seasons.LogInfo($"Loaded from cache revision:{revision} controllers:{controllers.Count} textures:{textures.Count}");
			}
			else
			{
				SeasonalTexturePrefabCache.SetCurrentTextureVariants(this);
				Seasons.StartCoroutineSync(SeasonalTexturePrefabCache.FillWithGameData());
				Seasons.StartCoroutineSync(SaveCacheOnDisk());
			}
			return Initialized();
		}

		public IEnumerator SaveCacheOnDisk()
		{
			if (!Initialized())
			{
				yield break;
			}
			CachedData cachedData = new CachedData(revision);
			cachedData.textures.Clear();
			foreach (KeyValuePair<int, TextureVariants> texVariants in textures)
			{
				CachedData.TextureData texData = new CachedData.TextureData(texVariants.Value);
				if (texData.Initialized())
				{
					cachedData.textures.Add(texVariants.Key, texData);
				}
			}
			Thread internalThread = new Thread((ThreadStart)delegate
			{
				DictionaryExt.Copy<string, PrefabController>(cachedData.controllers, controllers);
				if (Directory.Exists(cachedData.CacheDirectory()))
				{
					Directory.Delete(cachedData.CacheDirectory(), recursive: true);
				}
				cachedData.SaveOnDisk();
			});
			internalThread.Start();
			while (internalThread.IsAlive)
			{
				yield return Seasons.waitForFixedUpdate;
			}
			ApplyTexturesToGPU();
		}

		public bool Initialized()
		{
			return controllers.Count > 0 && textures.Count > 0;
		}

		public void ApplyTexturesToGPU()
		{
			foreach (KeyValuePair<int, TextureVariants> texture in textures)
			{
				texture.Value.ApplyTextures();
			}
		}

		public IEnumerator ReloadCache()
		{
			Stopwatch stopwatch = Stopwatch.StartNew();
			CachedData cachedData = new CachedData(SeasonalTexturePrefabCache.GetRevision());
			Thread internalThread = new Thread((ThreadStart)delegate
			{
				cachedData.LoadFromDisk();
			});
			internalThread.Start();
			while (internalThread.IsAlive)
			{
				yield return Seasons.waitForFixedUpdate;
			}
			if (cachedData.Initialized())
			{
				revision = cachedData.revision;
				foreach (KeyValuePair<int, CachedData.TextureData> texData in cachedData.textures)
				{
					if (!textures.ContainsKey(texData.Key))
					{
						TextureVariants texVariants = new TextureVariants(texData.Value);
						if (texVariants.Initialized())
						{
							textures.Add(texData.Key, texVariants);
						}
					}
				}
				internalThread = new Thread((ThreadStart)delegate
				{
					DictionaryExt.Copy<string, PrefabController>(controllers, cachedData.controllers);
				});
				internalThread.Start();
				while (internalThread.IsAlive)
				{
					yield return Seasons.waitForFixedUpdate;
				}
				Seasons.LogInfo($"Loaded from cache revision:{revision} controllers:{controllers.Count} textures:{textures.Count} in {stopwatch.Elapsed.TotalSeconds,-4:F2} seconds");
				stopwatch.Restart();
				ClutterVariantController.Reinitialize();
				PrefabVariantController.ReinitializePrefabVariants();
				yield return Seasons.waitForFixedUpdate;
				PrefabVariantController.UpdatePrefabColors();
				ClutterVariantController.Instance.UpdateColors();
				Seasons.LogInfo($"Colors reinitialized in {stopwatch.Elapsed.TotalSeconds,-4:F2} seconds");
			}
			else
			{
				yield return RebuildCache();
			}
		}

		public IEnumerator RebuildCache()
		{
			SeasonalTextureVariants newTexturesVariants = new SeasonalTextureVariants();
			SeasonalTexturePrefabCache.SetCurrentTextureVariants(newTexturesVariants);
			PrefabVariantController.instance.RevertPrefabsState();
			ClutterVariantController.Instance.RevertColors();
			yield return Seasons.waitForFixedUpdate;
			yield return SeasonalTexturePrefabCache.FillWithGameData();
			if (newTexturesVariants.Initialized())
			{
				Stopwatch stopwatch = Stopwatch.StartNew();
				controllers.Clear();
				textures.Clear();
				revision = newTexturesVariants.revision;
				Thread internalThread = new Thread((ThreadStart)delegate
				{
					DictionaryExt.Copy<string, PrefabController>(controllers, newTexturesVariants.controllers);
					DictionaryExt.Copy<int, TextureVariants>(textures, newTexturesVariants.textures);
				});
				internalThread.Start();
				while (internalThread.IsAlive)
				{
					yield return Seasons.waitForFixedUpdate;
				}
				yield return SaveCacheOnDisk();
				SeasonalTexturePrefabCache.SetCurrentTextureVariants(this);
				ClutterVariantController.Reinitialize();
				PrefabVariantController.ReinitializePrefabVariants();
				yield return Seasons.waitForFixedUpdate;
				Seasons.LogInfo($"Colors reinitialized in {stopwatch.Elapsed.TotalSeconds,-4:F2} seconds");
			}
			yield return Seasons.waitForFixedUpdate;
			SeasonalTexturePrefabCache.SetCurrentTextureVariants(this);
			PrefabVariantController.UpdatePrefabColors();
			ClutterVariantController.Instance?.UpdateColors();
		}
	}
	public static class SeasonalTexturePrefabCache
	{
		[Serializable]
		public struct FloatRange
		{
			public float start;

			public float end;

			public FloatRange(float start, float end)
			{
				this.start = start;
				this.end = end;
			}

			public readonly bool Fits(float value)
			{
				return (start == 0f || start <= value) && (end == 0f || value <= end);
			}

			public override readonly string ToString()
			{
				return $"{start}-{end}";
			}
		}

		[Serializable]
		public struct IntRange
		{
			public int start;

			public int end;

			public IntRange(int start, int end)
			{
				this.start = start;
				this.end = end;
			}

			public readonly bool Fits(int value)
			{
				return (start == 0 || start <= value) && (end == 0 || value <= end);
			}

			public override readonly string ToString()
			{
				return $"{start}-{end}";
			}
		}

		[Serializable]
		public class MaterialCacheSettings
		{
			public List<string> particleSystemStartColors;

			public Dictionary<string, string[]> shadersTypes;

			public Dictionary<string, string[]> shaderColors;

			public Dictionary<string, string[]> materialColors;

			public Dictionary<string, string[]> shaderTextures;

			public Dictionary<string, string[]> materialTextures;

			public Dictionary<string, string[]> shaderIgnoreMaterial;

			public Dictionary<string, string[]> shaderOnlyMaterial;

			public List<string> effectPrefab;

			public List<string> creaturePrefab;

			public List<string> piecePrefab;

			public List<string> piecePrefabPartialName;

			public List<string> ignorePrefab;

			public List<string> ignorePrefabPartialName;

			public MaterialCacheSettings(bool loadDefaults = false)
			{
				if (loadDefaults)
				{
					particleSystemStartColors = new List<string> { "leaf_particles", "vfx_bush_destroyed", "vfx_bush_destroyed_heath", "vfx_bush_leaf_puff", "vfx_bush_leaf_puff_heath", "vfx_bush2_e_hit", "vfx_bush2_en_destroyed", "vfx_shrub_2_hit" };
					shaderColors = new Dictionary<string, string[]>
					{
						{
							"Custom/StaticRock",
							new string[1] { "_MossColor" }
						},
						{
							"Custom/Yggdrasil_root",
							new string[1] { "_MossColor" }
						}
					};
					materialColors = new Dictionary<string, string[]>
					{
						{
							"Vines_Mat",
							new string[1] { "_Color" }
						},
						{
							"carrot_blast",
							new string[1] { "_Color" }
						},
						{
							"barley_sapling",
							new string[1] { "_Color" }
						},
						{
							"Bush01_raspberry",
							new string[1] { "_Color" }
						},
						{
							"grasscross_mistlands_short",
							new string[1] { "_Color" }
						},
						{
							"Bush02_en",
							new string[1] { "_Color" }
						},
						{
							"shrub_heath",
							new string[1] { "_Color" }
						},
						{
							"bfp_straw_roof",
							new string[1] { "_Color" }
						},
						{
							"bfp_straw_roof_alpha",
							new string[1] { "_Color" }
						},
						{
							"bfp_straw_roof_corner_alpha",
							new string[1] { "_Color" }
						},
						{
							"bcp_clay",
							new string[1] { "_Color" }
						},
						{
							"Grausten_RoofSlab_mat",
							new string[1] { "_Color" }
						},
						{
							"Vine_Sapling_ashlands_mat",
							new string[1] { "_Color" }
						},
						{
							"Vines_ashlands_mat",
							new string[1] { "_Color" }
						}
					};
					materialTextures = new Dictionary<string, string[]>
					{
						{
							"swamptree1_log",
							new string[1] { "_MossTex" }
						},
						{
							"swamptree2_log",
							new string[1] { "_MossTex" }
						},
						{
							"swamptree1_bark",
							new string[1] { "_MossTex" }
						},
						{
							"swamptree2_bark",
							new string[1] { "_MossTex" }
						},
						{
							"swamptree_stump",
							new string[1] { "_MossTex" }
						},
						{
							"beech_bark",
							new string[1] { "_MossTex" }
						},
						{
							"oak_bark",
							new string[1] { "_MossTex" }
						},
						{
							"yggdrasil_branch",
							new string[1] { "_MossTex" }
						},
						{
							"Vines_Mat",
							new string[0]
						},
						{
							"Grausten_RoofSlab_mat",
							new string[0]
						},
						{
							"Vine_Sapling_ashlands_mat",
							new string[0]
						},
						{
							"Vines_ashlands_mat",
							new string[0]
						}
					};
					shaderTextures = new Dictionary<string, string[]>
					{
						{
							"Custom/Vegetation",
							new string[1] { "_MainTex" }
						},
						{
							"Custom/Grass",
							new string[2] { "_MainTex", "_TerrainColorTex" }
						},
						{
							"Custom/Creature",
							new string[1] { "_MainTex" }
						},
						{
							"Custom/Piece",
							new string[1] { "_MainTex" }
						},
						{
							"Custom/StaticRock",
							new string[1] { "_MossTex" }
						},
						{
							"Standard",
							new string[1] { "_MainTex" }
						},
						{
							"Particles/Standard Surface2",
							new string[1] { "_MainTex" }
						},
						{
							"Custom/Yggdrasil",
							new string[1] { "_MainTex" }
						}
					};
					shaderIgnoreMaterial = new Dictionary<string, string[]> { 
					{
						"Custom/Vegetation",
						new string[8] { "bark", "trunk", "_wood", "HildirFlowerGirland_", "HildirTentCloth_", "TraderTent_", "VinesBranch_mat", "VinesBranch_Ashlands_mat" }
					} };
					shaderOnlyMaterial = new Dictionary<string, string[]>
					{
						{
							"Custom/Piece",
							new string[10] { "straw", "RoofShingles", "beehive", "Midsummerpole_mat", "Pine_tree_xmas", "ReworkedValheim", "shipyardNewCloth", "M_Cloth_01", "bcp_clay", "Grausten_RoofSlab_mat" }
						},
						{
							"Custom/Creature",
							new string[12]
							{
								"HildirsLox", "lox", "lox_calf", "Draugr_Archer_mat", "Draugr_mat", "Draugr_elite_mat", "Abomination_mat", "greyling", "greydwarf", "greydwarf_elite",
								"greydwarf_shaman", "neck"
							}
						},
						{
							"Standard",
							new string[6] { "beech_particle", "birch_particle", "branch_particle", "branch_dead_particle", "oak_particle", "shoot_leaf_particle" }
						},
						{
							"Particles/Standard Surface2",
							new string[3] { "shrub2_leafparticle", "shrub2_leafparticle_heath", "leaf_en" }
						}
					};
					shadersTypes = new Dictionary<string, string[]>
					{
						{
							typeof(MeshRenderer).Name,
							new string[6] { "Custom/Vegetation", "Custom/Grass", "Custom/StaticRock", "Custom/Piece", "Custom/Yggdrasil", "Custom/Yggdrasil_root" }
						},
						{
							typeof(InstanceRenderer).Name,
							new string[2] { "Custom/Vegetation", "Custom/Grass" }
						},
						{
							typeof(SkinnedMeshRenderer).Name,
							new string[1] { "Custom/Creature" }
						},
						{
							typeof(ParticleSystemRenderer).Name,
							new string[2] { "Standard", "Particles/Standard Surface2" }
						}
					};
					effectPrefab = new List<string>
					{
						"lox_ragdoll", "loxcalf_ragdoll", "Draugr_elite_ragdoll", "Draugr_ragdoll", "Draugr_ranged_ragdoll", "Abomination_ragdoll", "Greydwarf_ragdoll", "Greydwarf_elite_ragdoll", "Greydwarf_Shaman_ragdoll", "Greyling_ragdoll",
						"vfx_beech_cut", "vfx_oak_cut", "vfx_yggashoot_cut", "vfx_bush_destroyed", "vfx_bush_destroyed_heath", "vfx_bush_leaf_puff", "vfx_bush_leaf_puff_heath", "vfx_bush2_e_hit", "vfx_bush2_en_destroyed"
					};
					creaturePrefab = new List<string> { "Lox", "Lox_Calf", "Draugr", "Draugr_Elite", "Draugr_Ranged", "Abomination", "Greydwarf", "Greydwarf_Elite", "Greydwarf_Shaman", "Greyling" };
					piecePrefab = new List<string> { "vines", "piece_beehive", "piece_maypole", "piece_xmastree", "VineAsh", "VineAsh_sapling" };
					piecePrefabPartialName = new List<string>
					{
						"wood_roof", "copper_roof", "goblin_roof", "roof_wood_", "roof_darkwood_", "elvenwood_roof", "BFP_FineWoodRoof", "cloth_roof", "BFP_ClayRoof", "piece_grausten_roof",
						"VineAsh"
					};
					ignorePrefab = new List<string>
					{
						"Rock_destructible_test", "HugeRoot1", "Hildir_cave", "PineTree_log", "PineTree_log_half", "MountainGrave01", "PineTree_log_halfOLD", "PineTree_logOLD", "sapling_magecap", "FirTree_log",
						"FirTree_log_half", "Hildir_crypt", "MountainGraveStone01", "crypt_skeleton_chest", "dungeon_sunkencrypt_irongate_rusty", "stonechest", "SunkenKit_int_towerwall", "SunkenKit_int_towerwall_LOD", "marker01", "marker02",
						"TheHive", "StoneVillage2", "VoltureNest", "CharredStone_Spawner", "SulfurArch", "FaderLocation", "LeviathanLava", "FernFiddleHeadAshlands", "DevKitchen", "DevDressingRoom",
						"DevGarden", "DevForge"
					};
					ignorePrefabPartialName = new List<string>
					{
						"Mistlands_GuardTower", "WoodHouse", "DevHouse", "StoneTower", "SunkenCrypt", "MountainCave", "Mistlands_Lighthouse", "Mistlands_Viaduct", "Mistlands_Dvergr", "Mistlands_Statue",
						"Mistlands_Excavation", "Mistlands_Giant", "Mistlands_Harbour", "Mistlands_Mine", "dvergrtown_", "OLD_wood_roof", "AbandonedLogCabin", "DrakeNest", "CharredRuins", "MorgenHole",
						"CharredTowerRuins", "CharredRuins", "CharredFortress", "PlaceofMystery", "DevWall", "blackmarble_creep_slope", "lavarock_", "lavabomb_", "FlametalRockstand", "cliff_ashlands",
						"AshlandsTree", "AshlandsBush", "AshlandsBranch", "Ashlands_rock", "instanced_ashlands_grass"
					};
				}
			}
		}

		[Serializable]
		public class ColorsCacheSettings
		{
			[Serializable]
			public class ColorVariant
			{
				public bool useColor = true;

				public string color;

				public float targetProportion = 0f;

				public bool preserveAlphaChannel = true;

				public bool reduceOriginalColorToGrayscale = false;

				public bool restoreLuminance = true;

				[NonSerialized]
				public Color colorValue = Color.black;

				public Color MergeColors(Color colorToMerge)
				{
					//IL_0017: Unknown result type (might be due to invalid IL or missing references)
					//IL_001c: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0029: Unknown result type (might be due to invalid IL or missing references)
					//IL_0124: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
					//IL_00db: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
					//IL_011b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0120: Unknown result type (might be due to invalid IL or missing references)
					//IL_0109: Unknown result type (might be due to invalid IL or missing references)
					if (!useColor)
					{
						return colorToMerge;
					}
					if (colorValue == Color.black && ColorUtility.ToHtmlStringRGBA(colorValue) != color && !ColorUtility.TryParseHtmlString(color, ref colorValue))
					{
						Seasons.LogInfo("Error at parsing color: (" + color + ")");
					}
					Color val = default(Color);
					((Color)(ref val))..ctor(colorValue.r, colorValue.g, colorValue.b, preserveAlphaChannel ? colorToMerge.a : colorValue.a);
					Color val2 = (Color)(reduceOriginalColorToGrayscale ? new Color(((Color)(ref colorToMerge)).grayscale, ((Color)(ref colorToMerge)).grayscale, ((Color)(ref colorToMerge)).grayscale, colorToMerge.a) : colorToMerge);
					HSLColor hSLColor = new HSLColor(Color.Lerp(val2, val, targetProportion));
					if (restoreLuminance)
					{
						hSLColor.l = new HSLColor(colorToMerge).l;
					}
					return hSLColor.ToRGBA();
				}

				public ColorVariant()
				{
					//IL_0028: Unknown result type (might be due to invalid IL or missing references)
					//IL_002d: Unknown result type (might be due to invalid IL or missing references)
					useColor = false;
				}

				public ColorVariant(Color color, float t)
				{
					//IL_0028: Unknown result type (might be due to invalid IL or missing references)
					//IL_002d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0040: Unknown result type (might be due to invalid IL or missing references)
					this.color = "#" + ColorUtility.ToHtmlStringRGBA(color);
					targetProportion = t;
				}

				public ColorVariant(Color color, float t, bool grayscale, bool restoreLuminance)
				{
					//IL_0028: Unknown result type (might be due to invalid IL or missing references)
					//IL_002d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0040: Unknown result type (might be due to invalid IL or missing references)
					this.color = "#" + ColorUtility.ToHtmlStringRGBA(color);
					targetProportion = t;
					reduceOriginalColorToGrayscale = grayscale;
					this.restoreLuminance = restoreLuminance;
				}
			}

			[Serializable]
			public class SeasonalColorVariants
			{
				public List<ColorVariant> Spring = new List<ColorVariant>();

				public List<ColorVariant> Summer = new List<ColorVariant>();

				public List<ColorVariant> Fall = new List<ColorVariant>();

				public List<ColorVariant> Winter = new List<ColorVariant>();

				public ColorVariant GetColorVariant(Seasons.Season season, int pos)
				{
					if (1 == 0)
					{
					}
					ColorVariant result = season switch
					{
						Seasons.Season.Spring => (pos > Spring.Count - 1) ? new ColorVariant() : Spring[Mathf.Clamp(pos, 0, 3)], 
						Seasons.Season.Summer => (pos > Summer.Count - 1) ? new ColorVariant() : Summer[Mathf.Clamp(pos, 0, 3)], 
						Seasons.Season.Fall => (pos > Fall.Count - 1) ? new ColorVariant() : Fall[Mathf.Clamp(pos, 0, 3)], 
						Seasons.Season.Winter => (pos > Winter.Count - 1) ? new ColorVariant() : Winter[Mathf.Clamp(pos, 0, 3)], 
						_ => (pos > Spring.Count - 1) ? new ColorVariant() : Spring[Mathf.Clamp(pos, 0, 3)], 
					};
					if (1 == 0)
					{
					}
					return result;
				}
			}

			[Serializable]
			public class SeasonalColorOverride
			{
				public SeasonalColorVariants colors = new SeasonalColorVariants();
			}

			[Serializable]
			public class PrefabOverrides : SeasonalColorOverride
			{
				public List<string> prefab = new List<string>();

				public PrefabOverrides(List<string> prefab, SeasonalColorVariants colors)
				{
					this.prefab = prefab;
					base.colors = colors;
				}
			}

			[Serializable]
			public class MaterialOverrides : SeasonalColorOverride
			{
				public List<string> material = new List<string>();

				public MaterialOverrides(List<string> material, SeasonalColorVariants colors)
				{
					this.material = material;
					base.colors = colors;
				}
			}

			public SeasonalColorVariants seasonal = new SeasonalColorVariants();

			public SeasonalColorVariants grass = new SeasonalColorVariants();

			public SeasonalColorVariants moss = new SeasonalColorVariants();

			public SeasonalColorVariants creature = new SeasonalColorVariants();

			public SeasonalColorVariants piece = new SeasonalColorVariants();

			public SeasonalColorVariants conifer = new SeasonalColorVariants();

			public SeasonalColorVariants bush = new SeasonalColorVariants();

			public List<PrefabOverrides> prefabOverrides = new List<PrefabOverrides>();

			public List<MaterialOverrides> materialOverrides = new List<MaterialOverrides>();

			private readonly Dictionary<string, SeasonalColorVariants> _prefabs = new Dictionary<string, SeasonalColorVariants>();

			private readonly Dictionary<string, SeasonalColorVariants> _materials = new Dictionary<string, SeasonalColorVariants>();

			public ColorsCacheSettings(bool loadDefaults = false)
			{
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_014b: 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_01a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0207: Unknown result type (might be due to invalid IL or missing references)
				//IL_0236: Unknown result type (might be due to invalid IL or missing references)
				//IL_0265: Unknown result type (might be due to invalid IL or missing references)
				//IL_0294: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0325: Unknown result type (might be due to invalid IL or missing references)
				//IL_0356: Unknown result type (might be due to invalid IL or missing references)
				//IL_0387: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_042a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0459: Unknown result type (might be due to invalid IL or missing references)
				//IL_0488: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_04e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0515: Unknown result type (might be due to invalid IL or missing references)
				//IL_0544: Unknown result type (might be due to invalid IL or missing references)
				//IL_0573: Unknown result type (might be due to invalid IL or missing references)
				//IL_05a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0604: Unknown result type (might be due to invalid IL or missing references)
				//IL_0635: Unknown result type (might be due to invalid IL or missing references)
				//IL_0666: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_06da: Unknown result type (might be due to invalid IL or missing references)
				//IL_0709: Unknown result type (might be due to invalid IL or missing references)
				//IL_0738: Unknown result type (might be due to invalid IL or missing references)
				//IL_0767: Unknown result type (might be due to invalid IL or missing references)
				//IL_0796: Unknown result type (might be due to invalid IL or missing references)
				//IL_07c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_07f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0823: Unknown result type (might be due to invalid IL or missing references)
				//IL_0852: Unknown result type (might be due to invalid IL or missing references)
				//IL_0881: Unknown result type (might be due to invalid IL or missing references)
				//IL_08b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_08e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0914: Unknown result type (might be due to invalid IL or missing references)
				//IL_0945: Unknown result type (might be due to invalid IL or missing references)
				//IL_0974: Unknown result type (might be due to invalid IL or missing references)
				//IL_09a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_09e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a17: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a46: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a75: Unknown result type (might be due to invalid IL or missing references)
				//IL_0aa4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0ad3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b02: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b31: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b60: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b91: Unknown result type (might be due to invalid IL or missing references)
				//IL_0bc2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0bf3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0c24: Unknown result type (might be due to invalid IL or missing references)
				//IL_0c53: Unknown result type (might be due to invalid IL or missing references)
				//IL_0c82: Unknown result type (might be due to invalid IL or missing references)
				//IL_0cc7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0cf6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0d25: Unknown result type (might be due to invalid IL or missing references)
				//IL_0d54: Unknown result type (might be due to invalid IL or missing references)
				//IL_0d83: Unknown result type (might be due to invalid IL or missing references)
				//IL_0db2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0de1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0e10: Unknown result type (might be due to invalid IL or missing references)
				//IL_0e3f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0e70: Unknown result type (might be due to invalid IL or missing references)
				//IL_0ea1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0ed2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0f03: Unknown result type (might be due to invalid IL or missing references)
				//IL_0f34: Unknown result type (might be due to invalid IL or missing references)
				//IL_0f65: Unknown result type (might be due to invalid IL or missing references)
				//IL_0f96: Unknown result type (might be due to invalid IL or missing references)
				//IL_0fc7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0ff8: Unknown result type (might be due to invalid IL or missing references)
				//IL_1029: Unknown result type (might be due to invalid IL or missing references)
				//IL_105a: Unknown result type (might be due to invalid IL or missing references)
				//IL_10a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_10ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_10f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_1118: Unknown result type (might be due to invalid IL or missing references)
				//IL_1171: Unknown result type (might be due to invalid IL or missing references)
				//IL_1198: Unknown result type (might be due to invalid IL or missing references)
				//IL_11bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_11e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_1272: Unknown result type (might be due to invalid IL or missing references)
				//IL_1299: Unknown result type (might be due to invalid IL or missing references)
				//IL_12c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_12e7: Unknown result type (might be due to invalid IL or missing references)
				if (!loadDefaults)
				{
					return;
				}
				seasonal.Spring.Add(new ColorVariant(new Color(0.27f, 0.8f, 0.27f), 0.75f));
				seasonal.Spring.Add(new ColorVariant(new Color(0.69f, 0.84f, 0.15f), 0.75f));
				seasonal.Spring.Add(new ColorVariant(new Color(0.43f, 0.56f, 0.11f), 0.75f));
				seasonal.Spring.Add(new ColorVariant());
				seasonal.Summer.Add(new ColorVariant(new Color(0.5f, 0.7f, 0.2f), 0.5f));
				seasonal.Summer.Add(new ColorVariant(new Color(0.7f, 0.7f, 0.2f), 0.5f));
				seasonal.Summer.Add(new ColorVariant(new Color(0.5f, 0.5f, 0f), 0.5f));
				seasonal.Summer.Add(new ColorVariant(new Color(0.7f, 0.7f, 0f), 0.2f));
				seasonal.Fall.Add(new ColorVariant(new Color(0.8f, 0.5f, 0f), 0.75f));
				seasonal.Fall.Add(new ColorVariant(new Color(0.8f, 0.3f, 0f), 0.75f));
				seasonal.Fall.Add(new ColorVariant(new Color(0.8f, 0.2f, 0f), 0.7f));
				seasonal.Fall.Add(new ColorVariant(new Color(0.7f, 0.7f, 0f), 0.2f));
				seasonal.Winter.Add(new ColorVariant(new Color(1f, 0.98f, 0.98f), 0.65f, grayscale: true, restoreLuminance: false));
				seasonal.Winter.Add(new ColorVariant(new Color(1f, 1f, 1f), 0.6f, grayscale: true, restoreLuminance: false));
				seasonal.Winter.Add(new ColorVariant(new Color(0.98f, 0.98f, 1f), 0.65f, grayscale: true, restoreLuminance: false));
				seasonal.Winter.Add(new ColorVariant(new Color(1f, 1f, 1f), 0.65f, grayscale: true, restoreLuminance: false));
				grass.Spring.Add(new ColorVariant(new Color(0.45f, 0.8f, 0.27f), 0.5f));
				grass.Spring.Add(new ColorVariant(new Color(0.69f, 0.84f, 0.15f), 0.45f));
				grass.Spring.Add(new ColorVariant(new Color(0.51f, 0.65f, 0.13f), 0.5f));
				grass.Spring.Add(new ColorVariant());
				grass.Summer.Add(new ColorVariant(new Color(0.5f, 0.7f, 0.2f), 0.5f));
				grass.Summer.Add(new ColorVariant(new Color(0.7f, 0.75f, 0.2f), 0.5f));
				grass.Summer.Add(new ColorVariant(new Color(0.5f, 0.5f, 0f), 0.5f));
				grass.Summer.Add(new ColorVariant(new Color(0.7f, 0.7f, 0f), 0.2f));
				grass.Fall.Add(new ColorVariant(new Color(0.8f, 0.6f, 0.2f), 0.5f));
				grass.Fall.Add(new ColorVariant(new Color(0.8f, 0.5f, 0f), 0.5f));
				grass.Fall.Add(new ColorVariant(new Color(0.8f, 0.3f, 0f), 0.4f));
				grass.Fall.Add(new ColorVariant(new Color(0.7f, 0.7f, 0f), 0.4f));
				grass.Winter.Add(new ColorVariant(new Color(1f, 0.98f, 0.98f), 0.65f, grayscale: true, restoreLuminance: false));
				grass.Winter.Add(new ColorVariant(new Color(1f, 1f, 1f), 0.6f, grayscale: true, restoreLuminance: false));
				grass.Winter.Add(new ColorVariant(new Color(0.98f, 0.98f, 1f), 0.65f, grayscale: true, restoreLuminance: false));
				grass.Winter.Add(new ColorVariant(new Color(1f, 1f, 1f), 0.65f, grayscale: true, restoreLuminance: false));
				moss.Spring.Add(new ColorVariant(new Color(0.43f, 0.56f, 0.11f), 0.25f));
				moss.Spring.Add(new ColorVariant());
				moss.Spring.Add(new ColorVariant(new Color(0.27f, 0.8f, 0.27f), 0.25f));
				moss.Spring.Add(new ColorVariant(new Color(0.69f, 0.84f, 0.15f), 0.25f));
				moss.Summer.Add(new ColorVariant(new Color(0.5f, 0.5f, 0f), 0.2f));
				moss.Summer.Add(new ColorVariant(new Color(0.7f, 0.7f, 0f), 0.07f));
				moss.Summer.Add(new ColorVariant(new Color(0.5f, 0.7f, 0.2f), 0.2f));
				moss.Summer.Add(new ColorVariant(new Color(0.7f, 0.75f, 0.2f), 0.2f));
				moss.Fall.Add(new ColorVariant(new Color(0.8f, 0.3f, 0f), 0.2f));
				moss.Fall.Add(new ColorVariant(new Color(0.7f, 0.7f, 0f), 0.1f));
				moss.Fall.Add(new ColorVariant(new Color(0.8f, 0.6f, 0.2f), 0.2f));
				moss.Fall.Add(new ColorVariant(new Color(0.8f, 0.5f, 0f), 0.2f));
				moss.Winter.Add(new ColorVariant(new Color(0.98f, 0.98f, 1f), 0.65f, grayscale: true, restoreLuminance: false));
				moss.Winter.Add(new ColorVariant(new Color(1f, 1f, 1f), 0.65f, grayscale: true, restoreLuminance: false));
				moss.Winter.Add(new ColorVariant(new Color(1f, 0.98f, 0.98f), 0.65f, grayscale: true, restoreLuminance: false));
				moss.Winter.Add(new ColorVariant(new Color(1f, 1f, 1f), 0.6f, grayscale: true, restoreLuminance: false));
				conifer.Spring.Add(new ColorVariant(new Color(0.27f, 0.8f, 0.27f), 0.35f));
				conifer.Spring.Add(new ColorVariant(new Color(0.69f, 0.84f, 0.15f), 0.35f));
				conifer.Spring.Add(new ColorVariant(new Color(0.43f, 0.56f, 0.11f), 0.35f));
				conifer.Spring.Add(new ColorVariant());
				conifer.Summer.Add(new ColorVariant(new Color(0.5f, 0.7f, 0.2f), 0.25f));
				conifer.Summer.Add(new ColorVariant(new Color(0.7f, 0.7f, 0.2f), 0.25f));
				conifer.Summer.Add(new ColorVariant(new Color(0.5f, 0.5f, 0f), 0.25f));
				conifer.Summer.Add(new ColorVariant(new Color(0.7f, 0.7f, 0f), 0.1f));
				conifer.Fall.Add(new ColorVariant(new Color(0.8f, 0.5f, 0f), 0.25f));
				conifer.Fall.Add(new ColorVariant(new Color(0.8f, 0.3f, 0f), 0.2f));
				conifer.Fall.Add(new ColorVariant(new Color(0.8f, 0.2f, 0f), 0.15f));
				conifer.Fall.Add(new ColorVariant(new Color(0.7f, 0.7f, 0f), 0.1f));
				conifer.Winter.Add(new ColorVariant(new Color(1f, 0.98f, 0.98f), 0.45f, grayscale: true, restoreLuminance: false));
				conifer.Winter.Add(new ColorVariant(new Color(1f, 1f, 1f), 0.4f, grayscale: true, restoreLuminance: false));
				conifer.Winter.Add(new ColorVariant(new Color(0.98f, 0.98f, 1f), 0.45f, grayscale: true, restoreLuminance: false));
				conifer.Winter.Add(new ColorVariant(new Color(1f, 1f, 1f), 0.45f, grayscale: true, restoreLuminance: false));
				bush.Spring.Add(new ColorVariant(new Color(0.27f, 0.8f, 0.27f), 0.6f));
				bush.Spring.Add(new ColorVariant(new Color(0.69f, 0.84f, 0.15f), 0.6f));
				bush.Spring.Add(new ColorVariant(new Color(0.43f, 0.56f, 0.11f), 0.6f));
				bush.Spring.Add(new ColorVariant());
				bush.Summer.Add(new ColorVariant(new Color(0.5f, 0.7f, 0.2f), 0.5f));
				bush.Summer.Add(new ColorVariant(new Color(0.7f, 0.7f, 0.2f), 0.5f));
				bush.Summer.Add(new ColorVariant(new Color(0.5f, 0.5f, 0f), 0.5f));
				bush.Summer.Add(new ColorVariant(new Color(0.7f, 0.7f, 0f), 0.2f));
				bush.Fall.Add(new ColorVariant(new Color(0.8f, 0.5f, 0f), 0.5f));
				bush.Fall.Add(new ColorVariant(new Color(0.8f, 0.3f, 0f), 0.5f));
				bush.Fall.Add(new ColorVariant(new Color(0.8f, 0.2f, 0f), 0.4f));
				bush.Fall.Add(new ColorVariant(new Color(0.7f, 0.7f, 0f), 0.2f));
				bush.Winter.Add(new ColorVariant(new Color(1f, 0.98f, 0.98f), 0.65f, grayscale: true, restoreLuminance: false));
				bush.Winter.Add(new ColorVariant(new Color(1f, 1f, 1f), 0.6f, grayscale: true, restoreLuminance: false));
				bush.Winter.Add(new ColorVariant(new Color(0.98f, 0.98f, 1f), 0.65f, grayscale: true, restoreLuminance: false));
				bush.Winter.Add(new ColorVariant(new Color(1f, 1f, 1f), 0.65f, grayscale: true, restoreLuminance: false));
				creature.Winter.Add(new ColorVariant(new Color(1f, 0.98f, 0.98f), 0.25f, grayscale: true, restoreLuminance: false));
				creature.Winter.Add(new ColorVariant(new Color(1f, 1f, 1f), 0.2f, grayscale: true, restoreLuminance: false));
				creature.Winter.Add(new ColorVariant(new Color(0.98f, 0.98f, 1f), 0.25f, grayscale: true, restoreLuminance: false));
				creature.Winter.Add(new ColorVariant(new Color(1f, 1f, 1f), 0.25f, grayscale: true, restoreLuminance: false));
				piece.Winter.Add(new ColorVariant(new Color(1f, 0.98f, 0.98f), 0.4f, grayscale: true, restoreLuminance: false));
				piece.Winter.Add(new ColorVariant(new Color(1f, 1f, 1f), 0.3f, grayscale: true, restoreLuminance: false));
				piece.Winter.Add(new ColorVariant(new Color(0.98f, 0.98f, 1f), 0.4f, grayscale: true, restoreLuminance: false));
				piece.Winter.Add(new ColorVariant(new Color(1f, 1f, 1f), 0.4f, grayscale: true, restoreLuminance: false));
				prefabOverrides.Add(new PrefabOverrides(new List<string> { "lox" }, new SeasonalColorVariants
				{
					Winter = new List<ColorVariant>
					{
						new ColorVariant(new Color(1f, 0.98f, 0.98f), 0.5f, grayscale: true, restoreLuminance: false),
						new ColorVariant(new Color(1f, 1f, 1f), 0.4f, grayscale: true, restoreLuminance: false),
						new ColorVariant(new Color(0.98f, 0.98f, 1f), 0.5f, grayscale: true, restoreLuminance: false),
						new ColorVariant(new Color(1f, 1f, 1f), 0.5f, grayscale: true, restoreLuminance: false)
					}
				}));
				prefabOverrides.Add(new PrefabOverrides(new List<string> { "goblin" }, new SeasonalColorVariants
				{
					Winter = new List<ColorVariant>
					{
						new ColorVariant(new Color(1f, 0.98f, 0.98f), 0.35f, grayscale: true, restoreLuminance: false),
						new ColorVariant(new Color(1f, 1f, 1f), 0.3f, grayscale: true, restoreLuminance: false),
						new ColorVariant(new Color(0.98f, 0.98f, 1f), 0.35f, grayscale: true, restoreLuminance: false),
						new ColorVariant(new Color(1f, 1f, 1f), 0.35f, grayscale: true, restoreLuminance: false)
					}
				}));
				prefabOverrides.Add(new PrefabOverrides(new List<string> { "YggdrasilBranch" }, new SeasonalColorVariants
				{
					Spring = seasonal.Spring,
					Summer = seasonal.Summer,
					Fall = seasonal.Fall,
					Winter = new List<ColorVariant>
					{
						new ColorVariant(new Color(1f, 0.98f, 0.98f), 0.21f, grayscale: true, restoreLuminance: false),
						new ColorVariant(new Color(1f, 1f, 1f), 0.2f, grayscale: true, restoreLuminance: false),
						new ColorVariant(new Color(0.98f, 0.98f, 1f), 0.21f, grayscale: true, restoreLuminance: false),
						new ColorVariant(new Color(1f, 1f, 1f), 0.21f, grayscale: true, restoreLuminance: false)
					}
				}));
				prefabOverrides.Add(new PrefabOverrides(new List<string> { "grasscross_heath_green" }, new SeasonalColorVariants
				{
					Spring = grass.Summer,
					Summer = grass.Spring,
					Fall = grass.Summer,
					Winter = grass.Winter
				}));
				prefabOverrides.Add(new PrefabOverrides(new List<string> { "instanced_heathgrass" }, new SeasonalColorVariants
				{
					Spring = grass.Spring.Select((ColorVariant variant) => JsonUtility.FromJson<ColorVariant>(JsonUtility.ToJson((object)variant))).Select(delegate(ColorVariant variant)
					{
						if (!variant.useColor)
						{
							variant = grass.Spring[0];
						}
						variant.targetProportion += 0.2f;
						return variant;
					}).ToList(),
					Summer = grass.Summer,
					Fall = grass.Fall,
					Winter = grass.Winter
				}));
				materialOverrides.Add(new MaterialOverrides(new List<string> { "Pine_tree_small_dead", "swamptree1_branch", "swamptree2_branch" }, new SeasonalColorVariants
				{
					Winter = seasonal.Winter
				}));
				materialOverrides.Add(new MaterialOverrides(new List<string> { "Midsummerpole_mat" }, new SeasonalColorVariants
				{
					Spring = seasonal.Spring,
					Summer = seasonal.Summer,
					Fall = seasonal.Fall,
					Winter = seasonal.Winter
				}));
				materialOverrides.Add(new MaterialOverrides(new List<string> { "yggdrasil_branch" }, new SeasonalColorVariants
				{
					Spring = grass.Spring,
					Summer = grass.Summer,
					Fall = grass.Fall,
					Winter = grass.Winter
				}));
			}

			public SeasonalColorVariants GetPrefabOverride(string name)
			{
				if (_prefabs.Count == 0 && prefabOverrides.Count != 0)
				{
					foreach (PrefabOverrides prefabOverride in prefabOverrides)
					{
						foreach (string item in prefabOverride.prefab)
						{
							_prefabs.Add(item, prefabOverride.colors);
						}
					}
				}
				return GeneralExtensions.GetValueSafe<string, SeasonalColorVariants>(_prefabs, name);
			}

			public SeasonalColorVariants GetMaterialOverride(string name)
			{
				if (_materials.Count == 0 && materialOverrides.Count != 0)
				{
					foreach (MaterialOverrides materialOverride in materialOverrides)
					{
						foreach (string item in materialOverride.material)
						{
							_materials.Add(item, materialOverride.colors);
						}
					}
				}
				return GeneralExtensions.GetValueSafe<string, SeasonalColorVariants>(_materials, name);
			}

			public static bool IsGrass(string shaderName)
			{
				return shaderName == "Custom/Grass";
			}

			public static bool IsMoss(string textureName)
			{
				return textureName.IndexOf("moss", StringComparison.OrdinalIgnoreCase) >= 0;
			}

			public static bool IsPiece(Material material)
			{
				return ((Object)material.shader).name == "Custom/Piece" || ((Object)material).name.StartsWith("GoblinVillage");
			}

			public static bool IsCreature(string shaderName)
			{
				return shaderName == "Custom/Creature";
			}

			public static bool IsPine(string materialName, string prefab)
			{
				return materialName.IndexOf("pine", StringComparison.OrdinalIgnoreCase) >= 0 || prefab.IndexOf("pine", StringComparison.OrdinalIgnoreCase) >= 0;
			}

			public static bool IsBush(string materialName, string prefab)
			{
				return materialName.IndexOf("bush", StringComparison.OrdinalIgnoreCase) >= 0 || prefab.IndexOf("bush", StringComparison.OrdinalIgnoreCase) >= 0 || materialName.IndexOf("shrub", StringComparison.OrdinalIgnoreCase) >= 0 || prefab.IndexOf("shrub", StringComparison.OrdinalIgnoreCase) >= 0;
			}
		}

		[Serializable]
		public class ColorReplacementSpecifications
		{
			[Serializable]
			public class ColorFits
			{
				public FloatRange hue;

				public FloatRange saturation;

				public FloatRange luminance;

				public ColorFits(float hue1 = 0f, float hue2 = 360f, float s1 = 0f, float s2 = 1f, float l1 = 0f, float l2 = 1f)
				{
					hue = new FloatRange(hue1, hue2);
					saturation = new FloatRange(s1, s2);
					luminance = new FloatRange(l1, l2);
				}

				public bool Fits(HSLColor hslcolor)
				{
					return hue.Fits(hslcolor.h) && saturation.Fits(hslcolor.s) && luminance.Fits(hslcolor.l);
				}

				public override string ToString()
				{
					return $"hue:{hue} sat:{saturation} lum:{luminance}";
				}
			}

			[Serializable]
			public class ColorSpecific
			{
				public List<MaterialFits> material = new List<MaterialFits>();

				public List<ColorFits> colors = new List<ColorFits>();

				public ColorSpecific(List<MaterialFits> material, List<ColorFits> colors)
				{
					this.material = material;
					this.colors = colors;
				}

				public bool FitsMaterial(string prefabName, string rendererName, string materialName)
				{
					return MaterialFits.FitsMaterial(material, prefabName, rendererName, materialName);
				}

				public bool FitsColor(HSLColor color)
				{
					return Fits(colors, color);
				}
			}

			public List<ColorFits> seasonal = new List<ColorFits>();

			public List<ColorFits> grass = new List<ColorFits>();

			public List<ColorFits> moss = new List<ColorFits>();

			public List<ColorSpecific> specific = new List<ColorSpecific>();

			public ColorReplacementSpecifications(bool loadDefaults = false)
			{
				if (loadDefaults)
				{
					seasonal.Add(new ColorFits(80f, 160f, 0.15f));
					seasonal.Add(new ColorFits(55f, 91f, 0.2f, 1f, 0.18f));
					seasonal.Add(new ColorFits(33f, 57f, 0.28f, 1f, 0.26f));
					moss.Add(new ColorFits());
					grass.Add(new ColorFits(65f, 135f, 0.13f));
					grass.Add(new ColorFits(55f, 65f, 0.53f, 1f, 0.5f));
					grass.Add(new ColorFits(35f, 65f, 0f, 0.39f, 0.28f));
					grass.Add(new ColorFits(40f, 60f, 0.4f));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits("HildirsLox"),
						new MaterialFits(null, "Lox"),
						new MaterialFits(null, "lox_ragdoll"),
						new MaterialFits(null, null, "Furr", only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits(19f, 51f, 0.4f, 1f, 0f, 0.45f),
						new ColorFits(43f, 51f, 0f, 0.45f, 0f, 0.45f)
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "Lox_Calf", null, only: true),
						new MaterialFits(null, null, "Furr", only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits(38f, 62f, 0f, 0.55f, 0.18f)
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "draugr", null, only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits(80f, 160f, 0.15f),
						new ColorFits(55f, 91f, 0.19f, 1f, 0f, 0.4f)
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "Abomination", null, only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits(80f, 160f, 0.15f),
						new ColorFits(55f, 91f, 0.19f, 1f, 0f, 0.5f)
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "grey", null, only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits(80f, 160f, 0.15f),
						new ColorFits(51f, 91f, 0.18f, 1f, 0f, 0.5f)
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits("Vines_Mat", null, null, only: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits("Vine_Sapling_ashlands_mat", null, null, only: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits("Vines_ashlands_mat", null, null, only: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "goblin_roof", null, only: true, partial: true),
						new MaterialFits("GoblinVillage_Cloth", null, null, only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "darkwood_roof", null, only: true, partial: true),
						new MaterialFits("RoofShingles", null, null, only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "copper_roof", null, only: true, partial: true),
						new MaterialFits("RoofShingles", null, null, only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "wood_roof", null, only: true, partial: true),
						new MaterialFits("straw", null, null, only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits("Pine_tree_small_dead", null, null, only: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "shrub_2_heath", null, only: true),
						new MaterialFits("shrub_heath", null, null, only: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "instanced_meadows_grass", null, only: true),
						new MaterialFits("grasscross_meadows", null, null, only: true)
					}, new List<ColorFits>
					{
						new ColorFits(2f)
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "instanced_meadows_grass_short", null, only: true),
						new MaterialFits("grasscross_meadows_short", null, null, only: true)
					}, new List<ColorFits>
					{
						new ColorFits(2f)
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "instanced_mistlands_grass_short", null, only: true),
						new MaterialFits("grasscross_mistlands_short", null, null, only: true)
					}, new List<ColorFits>
					{
						new ColorFits(2f)
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits("neck", null, null, only: true),
						new MaterialFits(null, "Neck", null, only: true),
						new MaterialFits(null, null, "Lillies", only: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits("leafparticle", null, null, only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "roof_wood_", null, only: true, partial: true),
						new MaterialFits("straw", null, null, only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "roof_darkwood_", null, only: true, partial: true),
						new MaterialFits("RoofShingles", null, null, only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "elvenwood_roof", null, only: true, partial: true),
						new MaterialFits("straw", null, null, only: false, partial: true),
						new MaterialFits("ReworkedValheim", null, null, only: false, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "BFP_FineWoodRoof", null, only: true, partial: true),
						new MaterialFits("straw", null, null, only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "cloth_roof", null, only: true, partial: true),
						new MaterialFits("shipyardNewCloth", null, null, only: false, partial: true),
						new MaterialFits("M_Cloth_01", null, null, only: false, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "BFP_ClayRoof", null, only: true, partial: true),
						new MaterialFits("bcp_clay", null, null, only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
					specific.Add(new ColorSpecific(new List<MaterialFits>
					{
						new MaterialFits(null, "piece_grausten_roof", null, only: true, partial: true),
						new MaterialFits("Grausten_RoofSlab_mat", null, null, only: true, partial: true)
					}, new List<ColorFits>
					{
						new ColorFits()
					}));
				}
			}

			public bool ReplaceColor(Color color, bool isGrass, bool isMoss, string prefabName = null, string rendererName = null, string materialName = null)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				if (color.a == 0f)
				{
					return false;
				}
				HSLColor color2 = new HSLColor(color);
				if (prefabName != null || rendererName != null || materialName != null)
				{
					foreach (ColorSpecific item in specific)
					{
						if (item.FitsMaterial(prefabName, rendererName, materialName))
						{
							return item.FitsColor(color2);
						}
					}
				}
				if (isGrass)
				{
					return Fits(grass, color2);
				}
				if (isMoss)
				{
					return Fits(moss, color2);
				}
				return Fits(seasonal, color2);
			}

			private static bool Fits(List<ColorFits> list, HSLColor color)
			{
				foreach (ColorFits item in list)
				{
					if (item.Fits(color))
					{
						return true;
					}
				}
				return false;
			}
		}

		[Serializable]
		public class MaterialFits
		{
			public string material;

			public string prefab;

			public string renderer;

			public bool only = false;

			public bool partial = false;

			public bool not = f