Decompiled source of CrowdControl Broforce v1.0.0

BepInEx/plugins/CrowdControl/ConnectorLib.JSON.dll

Decompiled a day ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("Warp World, Inc.")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("© 2025 Warp World, Inc.")]
[assembly: AssemblyFileVersion("5.0.9727.26524")]
[assembly: AssemblyInformationalVersion("5.0.9727.26524+3863de10ef7a620b1c411661d2fc30d749c952d0")]
[assembly: AssemblyProduct("ConnectorLib.JSON")]
[assembly: AssemblyTitle("ConnectorLib.JSON")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("5.0.9727.26524")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[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]
	[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;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ConnectorLib.JSON
{
	internal class AnnotatedEnumConverter<T> : JsonConverter<T> where T : struct, Enum
	{
		[AttributeUsage(AttributeTargets.Field)]
		public class JsonValueAttribute(string value) : Attribute()
		{
			public readonly string Value = value;
		}

		private static readonly Dictionary<T, JsonValueAttribute?> _attributes;

		static AnnotatedEnumConverter()
		{
			_attributes = ((T[])Enum.GetValues(typeof(T))).Select((T m) => new KeyValuePair<T, JsonValueAttribute>(m, GetAttributeOfType<JsonValueAttribute>(m))).ToDictionary();
		}

		private static T? GetAttributeOfType<T>(Enum enumVal) where T : Attribute
		{
			object[] array = enumVal.GetType().GetMembers().First((MemberInfo m) => string.Equals(m.Name, enumVal.ToString(), StringComparison.Ordinal))
				.GetCustomAttributes(typeof(T), inherit: false)
				.ToArray();
			if (array.Length == 0)
			{
				return null;
			}
			return (T)array[0];
		}

		public override void WriteJson(JsonWriter writer, T value, JsonSerializer serializer)
		{
			JsonValueAttribute jsonValueAttribute = _attributes[value];
			if (jsonValueAttribute != null)
			{
				serializer.Serialize(writer, (object)jsonValueAttribute.Value);
			}
			else
			{
				serializer.Serialize(writer, (object)Enum.GetName(typeof(T), value));
			}
		}

		public override T ReadJson(JsonReader reader, Type objectType, T existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			string value = serializer.Deserialize<string>(reader);
			if (value == null)
			{
				return default(T);
			}
			KeyValuePair<T, JsonValueAttribute>? keyValuePair = _attributes.Cast<KeyValuePair<T, JsonValueAttribute>?>().FirstOrDefault((KeyValuePair<T, JsonValueAttribute>? a) => a?.Value?.Value?.Equals(value, StringComparison.OrdinalIgnoreCase) == true);
			if (keyValuePair.HasValue)
			{
				return keyValuePair.Value.Key;
			}
			try
			{
				return (T)Enum.Parse(typeof(T), value, ignoreCase: true);
			}
			catch
			{
				return default(T);
			}
		}
	}
	public class CamelCaseStringEnumConverter : JsonConverter<Enum>
	{
		public override void WriteJson(JsonWriter writer, Enum? value, JsonSerializer serializer)
		{
			if (value == null)
			{
				serializer.Serialize(writer, (object)null);
			}
			else
			{
				serializer.Serialize(writer, (object)value.ToCamelCase());
			}
		}

		public override Enum ReadJson(JsonReader reader, Type objectType, Enum? existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			return ReadJToken(JToken.ReadFrom(reader), objectType);
		}

		public static Enum ReadJToken(JToken reader, Type objectType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			JTokenType type = reader.Type;
			if ((int)type != 6)
			{
				if ((int)type == 8)
				{
					string text = Extensions.Value<string>((IEnumerable<JToken>)reader);
					if (text == null)
					{
						throw new SerializationException("The value was null.");
					}
					try
					{
						return (Enum)Enum.Parse(objectType, text, ignoreCase: true);
					}
					catch (Exception)
					{
						throw new SerializationException("The value was not recognized.");
					}
				}
				throw new SerializationException("The value was not a string or number.");
			}
			int? num = Extensions.Value<int>((IEnumerable<JToken>)reader);
			if (!num.HasValue)
			{
				throw new SerializationException("The value was null.");
			}
			return (Enum)Enum.ToObject(objectType, num.Value);
		}
	}
	public class DataRequest : SimpleJSONRequest
	{
		public string key;

		public DataRequest(string key)
		{
			this.key = key;
			type = RequestType.DataRequest;
		}
	}
	public class DataResponse : SimpleJSONResponse
	{
		public string key;

		public JToken? value;

		public EffectStatus status;

		public long timeRemaining;

		public string? message;

		[JsonConstructor]
		public DataResponse(string key, EffectStatus status, object? value = null, long timeRemaining = 0L, string? message = null)
		{
			this.key = key;
			this.value = value.IfNotNull((Func<object, JToken?>)JToken.FromObject);
			this.status = status;
			this.timeRemaining = timeRemaining;
			this.message = message;
			type = ResponseType.DataResponse;
		}

		public static DataResponse SuccessIfDefined(string key, object? value, string failMessage = "")
		{
			if (value == null)
			{
				return Retry(key, 0L, failMessage);
			}
			if (value is string input && input.IsNullOrWhiteSpace())
			{
				return Retry(key, 0L, failMessage);
			}
			return Success(key, value);
		}

		public static DataResponse Success(string key, object? value)
		{
			return new DataResponse(key, EffectStatus.Success, value, 0L);
		}

		public static DataResponse Success(string key, object? value, string? message)
		{
			return new DataResponse(key, EffectStatus.Success, value, 0L, message);
		}

		public static DataResponse Failure(string key)
		{
			return new DataResponse(key, EffectStatus.Failure, null, 0L);
		}

		public static DataResponse Failure(string key, string? message)
		{
			return new DataResponse(key, EffectStatus.Failure, null, 0L, message);
		}

		public static DataResponse Failure(string key, object? value, string? message = null)
		{
			return new DataResponse(key, EffectStatus.Failure, value, 0L, message);
		}

		public static DataResponse Retry(string key, long delay = 0L, string? message = null)
		{
			return new DataResponse(key, EffectStatus.Retry, null, delay, message);
		}
	}
	public class EffectRequest : SimpleJSONRequest
	{
		public class Target
		{
			public string? service;

			public string? id;

			public string? name;

			public string? avatar;
		}

		public string? code;

		public string? message;

		public JToken? parameters;

		public uint? quantity;

		public JArray? targets;

		public long? duration;

		public string? viewer;

		public JArray? viewers;

		public long? cost;

		public Guid? requestID;

		[JsonConverter(typeof(IEffectSourceDetails.Converter))]
		public IEffectSourceDetails? sourceDetails;

		public EffectRequest()
		{
			type = RequestType.Start;
		}
	}
	public class EffectResponse : SimpleJSONResponse
	{
		private class MetadataConverter : JsonConverter<Dictionary<string, DataResponse>?>
		{
			public override void WriteJson(JsonWriter writer, Dictionary<string, DataResponse>? value, JsonSerializer serializer)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				if (value == null)
				{
					serializer.Serialize(writer, (object)null);
					return;
				}
				JObject val = new JObject();
				foreach (KeyValuePair<string, DataResponse> item in value)
				{
					JObject val2 = JObject.FromObject((object)item.Value);
					val2.Remove("key");
					val[item.Key] = (JToken)(object)val2;
				}
				serializer.Serialize(writer, (object)val);
			}

			public override Dictionary<string, DataResponse>? ReadJson(JsonReader reader, Type objectType, Dictionary<string, DataResponse>? existingValue, bool hasExistingValue, JsonSerializer serializer)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Expected O, but got Unknown
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Expected O, but got Unknown
				JObject val = (JObject)serializer.Deserialize(reader);
				if (val == null)
				{
					return null;
				}
				Dictionary<string, DataResponse> dictionary = new Dictionary<string, DataResponse>();
				foreach (JProperty item in val.Properties())
				{
					JObject val2 = (JObject)item.Value;
					val2["key"] = JToken.op_Implicit(item.Name);
					dictionary.Add(item.Name, ((JToken)val2).ToObject<DataResponse>());
				}
				return dictionary;
			}
		}

		public EffectStatus status;

		public string? message;

		public StandardErrors messageID;

		public long timeRemaining;

		[JsonConverter(typeof(MetadataConverter))]
		public Dictionary<string, DataResponse>? metadata;

		public EffectResponse()
		{
		}

		public EffectResponse(uint id, EffectStatus status)
			: this(id, status, 0L, null)
		{
		}

		public EffectResponse(uint id, EffectStatus status, StandardErrors messageID)
			: this(id, status, 0L, messageID)
		{
		}

		public EffectResponse(uint id, EffectStatus status, string? message)
			: this(id, status, 0L, message)
		{
		}

		public EffectResponse(uint id, EffectStatus status, TimeSpan timeRemaining)
			: this(id, status, checked((long)timeRemaining.TotalMilliseconds), null)
		{
		}

		public EffectResponse(uint id, EffectStatus status, TimeSpan timeRemaining, StandardErrors messageID)
			: this(id, status, checked((long)timeRemaining.TotalMilliseconds), messageID)
		{
		}

		public EffectResponse(uint id, EffectStatus status, TimeSpan timeRemaining, string? message)
			: this(id, status, checked((long)timeRemaining.TotalMilliseconds), message)
		{
		}

		public EffectResponse(uint id, EffectStatus status, long timeRemaining)
			: this(id, status, timeRemaining, null)
		{
		}

		public EffectResponse(uint id, EffectStatus status, long timeRemaining, StandardErrors messageID)
			: this(id, status, timeRemaining)
		{
			this.messageID = messageID;
		}

		[JsonConstructor]
		public EffectResponse(uint id, EffectStatus status, long timeRemaining, string? message)
		{
			base.id = id;
			this.status = status;
			this.timeRemaining = timeRemaining;
			this.message = message;
			type = ResponseType.EffectRequest;
		}

		public static EffectResponse Success(uint id, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Success, message);
		}

		public static EffectResponse Success(uint id, long delay, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Success, delay, message);
		}

		public static EffectResponse Success(uint id, TimeSpan delay, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Success, delay, message);
		}

		public static EffectResponse Failure(uint id, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Failure, message);
		}

		public static EffectResponse Failure(uint id, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Failure, error);
		}

		public static EffectResponse Unavailable(uint id, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Unavailable, message);
		}

		public static EffectResponse Unavailable(uint id, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Unavailable, error);
		}

		public static EffectResponse Retry(uint id, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Retry, 0L, message);
		}

		public static EffectResponse Retry(uint id, long delay, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Retry, delay, message);
		}

		public static EffectResponse Retry(uint id, TimeSpan delay, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Retry, delay, message);
		}

		public static EffectResponse Retry(uint id, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Retry, 0L, error);
		}

		public static EffectResponse Retry(uint id, long delay, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Retry, delay, error);
		}

		public static EffectResponse Retry(uint id, TimeSpan delay, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Retry, delay, error);
		}

		public static EffectResponse Paused(uint id, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Paused, 0L, message);
		}

		public static EffectResponse Paused(uint id, long timeRemaining, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Paused, timeRemaining, message);
		}

		public static EffectResponse Paused(uint id, TimeSpan timeRemaining, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Paused, timeRemaining, message);
		}

		public static EffectResponse Paused(uint id, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Paused, 0L, error);
		}

		public static EffectResponse Paused(uint id, long timeRemaining, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Paused, timeRemaining, error);
		}

		public static EffectResponse Paused(uint id, TimeSpan timeRemaining, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Paused, timeRemaining, error);
		}

		public static EffectResponse Resumed(uint id, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Resumed, 0L, message);
		}

		public static EffectResponse Resumed(uint id, long timeRemaining, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Resumed, timeRemaining, message);
		}

		public static EffectResponse Resumed(uint id, TimeSpan timeRemaining, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Resumed, timeRemaining, message);
		}

		public static EffectResponse Resumed(uint id, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Resumed, 0L, error);
		}

		public static EffectResponse Resumed(uint id, long timeRemaining, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Resumed, timeRemaining, error);
		}

		public static EffectResponse Resumed(uint id, TimeSpan timeRemaining, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Resumed, timeRemaining, error);
		}

		public static EffectResponse Finished(uint id, string? message = null)
		{
			return new EffectResponse(id, EffectStatus.Finished, 0L, message);
		}

		public static EffectResponse Finished(uint id, StandardErrors error)
		{
			return new EffectResponse(id, EffectStatus.Finished, 0L, error);
		}
	}
	public interface IEffectSourceDetails
	{
		public class Converter : JsonConverter<IEffectSourceDetails?>
		{
			public static readonly Converter Instance = new Converter();

			public override IEffectSourceDetails? ReadJson(JsonReader reader, Type objectType, IEffectSourceDetails? existingValue, bool hasExistingValue, JsonSerializer serializer)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				if ((int)reader.TokenType == 11)
				{
					return null;
				}
				JObject val = JObject.Load(reader);
				JToken obj = val["type"];
				return ((obj != null) ? Extensions.Value<string>((IEnumerable<JToken>)obj) : null) switch
				{
					"twitch-channel-reward" => ((JToken)val).ToObject<TwitchChannelRewardSourceDetails>(), 
					"stream-labs-donation" => ((JToken)val).ToObject<StreamLabsDonationSourceDetails>(), 
					"event-hype-train" => ((JToken)val).ToObject<HypeTrainSourceDetails>(), 
					"tiktok-gift" => ((JToken)val).ToObject<TikTokGiftSourceDetails>(), 
					"tiktok-like" => ((JToken)val).ToObject<TikTokLikeSourceDetails>(), 
					"tiktok-follow" => ((JToken)val).ToObject<TikTokFollowSourceDetails>(), 
					"tiktok-share" => ((JToken)val).ToObject<TikTokShareSourceDetails>(), 
					"pulsoid-trigger" => ((JToken)val).ToObject<PulsoidTriggerSourceDetails>(), 
					"crowd-control-test" => ((JToken)val).ToObject<CrowdControlTestSourceDetails>(), 
					"crowd-control-chaos-mode" => ((JToken)val).ToObject<CrowdControlChaosModeSourceDetails>(), 
					"crowd-control-retry" => ((JToken)val).ToObject<CrowdControlRetrySourceDetails>(), 
					_ => null, 
				};
			}

			public override void WriteJson(JsonWriter writer, IEffectSourceDetails? value, JsonSerializer serializer)
			{
				serializer.Serialize(writer, (object)((value == null) ? null : JObject.FromObject((object)value)));
			}
		}

		[JsonProperty("type")]
		string Type { get; }
	}
	public class TwitchChannelRewardSourceDetails : IEffectSourceDetails
	{
		[JsonProperty("type")]
		public string Type => "twitch-channel-reward";

		[JsonProperty("rewardID")]
		public string RewardID { get; set; }

		[JsonProperty("redemptionID")]
		public string RedemptionID { get; set; }

		[JsonProperty("twitchID")]
		public string TwitchID { get; set; }

		[JsonProperty("name")]
		public string Name { get; set; }

		[JsonProperty("cost")]
		public int Cost { get; set; }
	}
	public class StreamLabsDonationSourceDetails : IEffectSourceDetails
	{
		[JsonProperty("type")]
		public string Type => "stream-labs-donation";

		[JsonProperty("donationID")]
		public string DonationID { get; set; }

		[JsonProperty("cost")]
		public string Cost { get; set; }

		[JsonProperty("currency")]
		public string Currency { get; set; }

		[JsonProperty("name")]
		public string? Name { get; set; }

		[JsonProperty("message")]
		public string? Message { get; set; }
	}
	public class HypeTrainSourceDetails : IEffectSourceDetails
	{
		public class Contribution
		{
			[JsonProperty("user_id")]
			public string UserID { get; set; }

			[JsonProperty("user_login")]
			public string UserLogin { get; set; }

			[JsonProperty("user_name")]
			public string UserName { get; set; }

			[JsonProperty("type")]
			public string Type { get; set; }

			[JsonProperty("total")]
			public int Total { get; set; }
		}

		[JsonProperty("type")]
		public string Type => "event-hype-train";

		[JsonProperty("total")]
		public int Total { get; set; }

		[JsonProperty("progress")]
		public int Progress { get; set; }

		[JsonProperty("goal")]
		public int Goal { get; set; }

		[JsonProperty("top_contributions")]
		public List<Contribution> TopContributions { get; set; }

		[JsonProperty("last_contribution")]
		public Contribution LastContribution { get; set; }

		[JsonProperty("level")]
		public int Level { get; set; }
	}
	public abstract class TikTokSourceDetails : IEffectSourceDetails
	{
		[JsonProperty("type")]
		public abstract string Type { get; }

		[JsonProperty("cost")]
		public int Cost { get; set; }

		[JsonProperty("name")]
		public string Name { get; set; }

		[JsonProperty("userID")]
		public string UserID { get; set; }
	}
	public class TikTokGiftSourceDetails : TikTokSourceDetails
	{
		[JsonProperty("type")]
		public override string Type => "tiktok-gift";

		[JsonProperty("giftID")]
		public int GiftID { get; set; }

		[JsonProperty("giftName")]
		public string GiftName { get; set; }

		[JsonProperty("transactionID")]
		public string? TransactionID { get; set; }
	}
	public class TikTokLikeSourceDetails : TikTokSourceDetails
	{
		[JsonProperty("type")]
		public override string Type => "tiktok-like";
	}
	public class TikTokFollowSourceDetails : TikTokSourceDetails
	{
		[JsonProperty("type")]
		public override string Type => "tiktok-follow";
	}
	public class TikTokShareSourceDetails : TikTokSourceDetails
	{
		[JsonProperty("type")]
		public override string Type => "tiktok-share";
	}
	public class PulsoidTriggerSourceDetails : IEffectSourceDetails
	{
		[JsonProperty("type")]
		public string Type => "pulsoid-trigger";

		[JsonProperty("heartRate")]
		public int HeartRate { get; set; }

		[JsonProperty("uuid")]
		public Guid Uuid { get; set; }

		[JsonProperty("triggerType")]
		public string TriggerType { get; set; }

		[JsonProperty("targetHeartRate")]
		public int TargetHeartRate { get; set; }

		[JsonProperty("holdTime")]
		public int HoldTime { get; set; }

		[JsonProperty("cooldown")]
		public int Cooldown { get; set; }
	}
	public class CrowdControlTestSourceDetails : IEffectSourceDetails
	{
		[JsonProperty("type")]
		public string Type => "crowd-control-test";
	}
	public class CrowdControlChaosModeSourceDetails : IEffectSourceDetails
	{
		[JsonProperty("type")]
		public string Type => "crowd-control-chaos-mode";
	}
	public class CrowdControlRetrySourceDetails : IEffectSourceDetails
	{
		[JsonProperty("type")]
		public string Type => "crowd-control-retry";
	}
	[JsonConverter(typeof(CamelCaseStringEnumConverter))]
	public enum EffectStatus
	{
		Success = 0,
		Failure = 1,
		Unavailable = 2,
		Retry = 3,
		Queue = 4,
		Running = 5,
		Paused = 6,
		Resumed = 7,
		Finished = 8,
		Wait = 9,
		RemoteScheduled = 10,
		Visible = 128,
		NotVisible = 129,
		Selectable = 130,
		NotSelectable = 131,
		Reserved0 = 160,
		NotReady = 255
	}
	public class EffectUpdate : SimpleJSONResponse
	{
		[JsonConverter(typeof(CamelCaseStringEnumConverter))]
		public enum IdentifierType
		{
			Effect,
			Group,
			Category
		}

		[Obsolete("This field is deprecated. Please use the ids field instead.")]
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public string? code;

		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public string[]? ids;

		public IdentifierType idType;

		public EffectStatus status;

		public string? message;

		public EffectUpdate()
		{
		}

		public EffectUpdate(string code, EffectStatus status, string? message = null)
		{
			ids = new string[1] { code };
			idType = IdentifierType.Effect;
			this.status = status;
			this.message = message;
			type = ResponseType.EffectStatus;
		}

		public EffectUpdate(string[] ids, EffectStatus status, string? message = null)
		{
			this.ids = ids;
			idType = IdentifierType.Effect;
			this.status = status;
			this.message = message;
			type = ResponseType.EffectStatus;
		}

		public EffectUpdate(IEnumerable<string> ids, EffectStatus status, string? message = null)
		{
			this.ids = ids.ToArray();
			idType = IdentifierType.Effect;
			this.status = status;
			this.message = message;
			type = ResponseType.EffectStatus;
		}
	}
	public class EmptyRequest : SimpleJSONRequest
	{
	}
	public class EmptyResponse : SimpleJSONResponse
	{
	}
	internal static class EnumEx
	{
		internal static string ToCamelCase(this Enum value)
		{
			return value.ToString("G").ToCamelCase();
		}
	}
	[JsonConverter(typeof(CamelCaseStringEnumConverter))]
	public enum GameState
	{
		Unknown = 0,
		Ready = 1,
		Error = -1,
		Unmodded = -2,
		BadGameSettings = -3,
		WrongVersion = -4,
		NotFocused = -5,
		Loading = -6,
		Paused = -7,
		WrongMode = -8,
		SafeArea = -9,
		UntimedArea = -10,
		Cutscene = -11,
		BadPlayerState = -12,
		Menu = -13,
		Map = -14,
		InCombat = -15,
		NotInCombat = -16,
		PipelineBusy = -128
	}
	public class GameUpdate : SimpleJSONResponse
	{
		public GameState state;

		public string? message;

		public GameUpdate(GameState state, string? message = null)
		{
			this.state = state;
			this.message = message;
			type = ResponseType.GameUpdate;
		}
	}
	public class GenericEventRequest : SimpleJSONRequest
	{
		[JsonProperty(PropertyName = "internal")]
		public bool @internal;

		public string eventType;

		public Dictionary<string, object>? data;

		public GenericEventRequest(string eventType)
		{
			type = RequestType.GenericEvent;
			this.eventType = eventType;
		}

		[JsonConstructor]
		public GenericEventRequest(string eventType, IEnumerable<KeyValuePair<string, object>>? data)
			: this(eventType)
		{
			this.data = ((data != null) ? data.ToDictionary() : null);
		}

		[JsonConstructor]
		public GenericEventRequest(string eventType, IEnumerable<KeyValuePair<string, object>>? data, bool @internal)
			: this(eventType, data)
		{
			this.@internal = @internal;
		}
	}
	public class GenericEventResponse : SimpleJSONResponse
	{
		[JsonProperty(PropertyName = "internal")]
		public bool @internal;

		public string eventType;

		public Dictionary<string, object>? data;

		public GenericEventResponse(string eventType)
		{
			type = ResponseType.GenericEvent;
			this.eventType = eventType;
		}

		public GenericEventResponse(string eventType, IEnumerable<KeyValuePair<string, object>>? data, bool @internal = false)
			: this(eventType)
		{
			this.data = ((data != null) ? data.ToDictionary() : null);
			this.@internal = @internal;
		}

		[JsonConstructor]
		public GenericEventResponse(string eventType, Dictionary<string, object>? data, [JsonProperty(PropertyName = "internal")] bool @internal)
			: this(eventType, data)
		{
			this.@internal = @internal;
		}
	}
	internal class HexColorConverter : JsonConverter<ParameterColorValue>
	{
		private static readonly Dictionary<char, byte> CHAR_LOOKUP = new Dictionary<char, byte>
		{
			{ '0', 0 },
			{ '1', 1 },
			{ '2', 2 },
			{ '3', 3 },
			{ '4', 4 },
			{ '5', 5 },
			{ '6', 6 },
			{ '7', 7 },
			{ '8', 8 },
			{ '9', 9 },
			{ 'A', 10 },
			{ 'B', 11 },
			{ 'C', 12 },
			{ 'D', 13 },
			{ 'E', 14 },
			{ 'F', 15 }
		};

		public override void WriteJson(JsonWriter writer, ParameterColorValue value, JsonSerializer serializer)
		{
			serializer.Serialize(writer, (object)string.Format("#{0}{1:X2}{2:X2}{3:X2}", (value.A != byte.MaxValue) ? value.A.ToString("X2") : string.Empty, value.R, value.G, value.B));
		}

		public override ParameterColorValue ReadJson(JsonReader reader, Type objectType, ParameterColorValue existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			if (TryParse(serializer.Deserialize<string>(reader), out var color))
			{
				return color;
			}
			throw new SerializationException("Unrecognized color code.");
		}

		public static bool TryParse(string? value, out ParameterColorValue color)
		{
			if (value == null)
			{
				color = default(ParameterColorValue);
				return false;
			}
			value = value.TrimStart(new char[1] { '#' });
			switch (value.Length)
			{
			case 6:
			{
				string[] array2 = value.Chop(2);
				byte result2;
				byte red3 = (byte)(byte.TryParse(array2[0], NumberStyles.AllowHexSpecifier, NumberFormatInfo.InvariantInfo, out result2) ? result2 : 0);
				byte green3 = (byte)(byte.TryParse(array2[1], NumberStyles.AllowHexSpecifier, NumberFormatInfo.InvariantInfo, out result2) ? result2 : 0);
				byte blue3 = (byte)(byte.TryParse(array2[2], NumberStyles.AllowHexSpecifier, NumberFormatInfo.InvariantInfo, out result2) ? result2 : 0);
				color = ParameterColorValue.FromArgb(red3, green3, blue3);
				return true;
			}
			case 8:
			{
				string[] array = value.Chop(2);
				byte result;
				byte alpha2 = (byte)(byte.TryParse(array[0], NumberStyles.AllowHexSpecifier, NumberFormatInfo.InvariantInfo, out result) ? result : 0);
				byte red2 = (byte)(byte.TryParse(array[1], NumberStyles.AllowHexSpecifier, NumberFormatInfo.InvariantInfo, out result) ? result : 0);
				byte green2 = (byte)(byte.TryParse(array[2], NumberStyles.AllowHexSpecifier, NumberFormatInfo.InvariantInfo, out result) ? result : 0);
				byte blue2 = (byte)(byte.TryParse(array[3], NumberStyles.AllowHexSpecifier, NumberFormatInfo.InvariantInfo, out result) ? result : 0);
				color = ParameterColorValue.FromArgb(alpha2, red2, green2, blue2);
				return true;
			}
			case 3:
			{
				byte value3;
				byte red4 = (byte)(CHAR_LOOKUP.TryGetValue(value[0], out value3) ? checked((byte)(value3 * 16)) : 0);
				byte green4 = (byte)(CHAR_LOOKUP.TryGetValue(value[1], out value3) ? checked((byte)(value3 * 16)) : 0);
				byte blue4 = (byte)(CHAR_LOOKUP.TryGetValue(value[2], out value3) ? checked((byte)(value3 * 16)) : 0);
				color = ParameterColorValue.FromArgb(red4, green4, blue4);
				return true;
			}
			case 4:
			{
				byte value2;
				byte alpha = (byte)(CHAR_LOOKUP.TryGetValue(value[0], out value2) ? checked((byte)(value2 * 16)) : 0);
				byte red = (byte)(CHAR_LOOKUP.TryGetValue(value[1], out value2) ? checked((byte)(value2 * 16)) : 0);
				byte green = (byte)(CHAR_LOOKUP.TryGetValue(value[2], out value2) ? checked((byte)(value2 * 16)) : 0);
				byte blue = (byte)(CHAR_LOOKUP.TryGetValue(value[3], out value2) ? checked((byte)(value2 * 16)) : 0);
				color = ParameterColorValue.FromArgb(alpha, red, green, blue);
				return true;
			}
			default:
				color = default(ParameterColorValue);
				return false;
			}
		}
	}
	internal static class IEnumerableEx
	{
		internal static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> values) where TKey : notnull
		{
			Dictionary<TKey, TValue> dictionary = new Dictionary<TKey, TValue>();
			foreach (KeyValuePair<TKey, TValue> value in values)
			{
				dictionary.Add(value.Key, value.Value);
			}
			return dictionary;
		}
	}
	public interface IParameterValue
	{
		string ID { get; }

		string Name { get; }

		ParameterBase.ParameterType Type { get; }

		object? Value { get; }
	}
	public class LoginRequest : SimpleJSONRequest
	{
		public string? login;

		public string? password;
	}
	public class MessageRequest : SimpleJSONRequest
	{
		public string? message;
	}
	public class MessageResponse : SimpleJSONResponse
	{
		public string? message;
	}
	internal static class ObjectEx
	{
		internal static T2? IfNotNull<T1, T2>(this T1? value, Func<T1, T2?> selector) where T2 : class
		{
			if (value == null)
			{
				return null;
			}
			return selector(value);
		}
	}
	public abstract class ParameterBase
	{
		[JsonConverter(typeof(AnnotatedEnumConverter<ParameterType>))]
		public enum ParameterType
		{
			[AnnotatedEnumConverter<ParameterType>.JsonValue("options")]
			Options,
			[AnnotatedEnumConverter<ParameterType>.JsonValue("hex-color")]
			HexColor
		}

		[JsonIgnore]
		public readonly string ID;

		[JsonProperty(PropertyName = "title")]
		public readonly string Name;

		[JsonProperty(PropertyName = "type")]
		public readonly ParameterType Type;

		protected ParameterBase(string name, string id, ParameterType type)
		{
			ID = id;
			Name = name;
			Type = type;
		}
	}
	public class ParameterColor : ParameterBase, IParameterValue
	{
		[JsonProperty(PropertyName = "value")]
		[JsonConverter(typeof(HexColorConverter))]
		public ParameterColorValue Value;

		[JsonIgnore]
		string IParameterValue.ID => ID;

		[JsonIgnore]
		string IParameterValue.Name => Name;

		[JsonIgnore]
		ParameterType IParameterValue.Type => Type;

		[JsonIgnore]
		object? IParameterValue.Value => Value;

		[JsonConstructor]
		public ParameterColor(string name, string id, ParameterColorValue value)
			: base(name, id, ParameterType.HexColor)
		{
			Value = value;
		}

		[JsonConstructor]
		public ParameterColor(string name, string id, string value)
			: base(name, id, ParameterType.HexColor)
		{
			if (!HexColorConverter.TryParse(value, out Value))
			{
				throw new ArgumentException("Unknown color code.", "value");
			}
		}
	}
	[DebuggerDisplay("{NameAndARGBValue}")]
	public readonly struct ParameterColorValue : IEquatable<ParameterColorValue>
	{
		public static readonly ParameterColorValue Empty;

		private const short StateARGBValueValid = 2;

		private const short StateValueMask = 2;

		private const short StateNameValid = 8;

		private const long NotDefinedValue = 0L;

		internal const int ARGBAlphaShift = 24;

		internal const int ARGBRedShift = 16;

		internal const int ARGBGreenShift = 8;

		internal const int ARGBBlueShift = 0;

		internal const uint ARGBAlphaMask = 4278190080u;

		internal const uint ARGBRedMask = 16711680u;

		internal const uint ARGBGreenMask = 65280u;

		internal const uint ARGBBlueMask = 255u;

		private readonly long value;

		private readonly short state;

		public byte R => (byte)(Value >> 16);

		public byte G => (byte)(Value >> 8);

		public byte B => (byte)Value;

		public byte A => (byte)(Value >> 24);

		public bool IsEmpty => state == 0;

		private long Value
		{
			get
			{
				if ((state & 2) != 0)
				{
					return value;
				}
				return 0L;
			}
		}

		private ParameterColorValue(long value, short state)
		{
			this.value = value;
			this.state = state;
		}

		private static ParameterColorValue FromArgb(uint argb)
		{
			return new ParameterColorValue(argb, 2);
		}

		public static ParameterColorValue FromArgb(int argb)
		{
			return FromArgb((uint)argb);
		}

		public static ParameterColorValue FromArgb(byte alpha, byte red, byte green, byte blue)
		{
			return FromArgb((uint)((alpha << 24) | (red << 16) | (green << 8) | blue));
		}

		public static ParameterColorValue FromArgb(int alpha, ParameterColorValue baseColor)
		{
			return FromArgb(checked(((uint)alpha << 24) | ((uint)baseColor.Value & 0xFFFFFF)));
		}

		public static ParameterColorValue FromArgb(byte red, byte green, byte blue)
		{
			return FromArgb(byte.MaxValue, red, green, blue);
		}

		private void GetRgbValues(out byte r, out byte g, out byte b)
		{
			checked
			{
				uint num = (uint)Value;
				r = (byte)((num & 0xFF0000) >> 16);
				g = (byte)((num & 0xFF00) >> 8);
				b = (byte)(num & 0xFF);
			}
		}

		public float GetBrightness()
		{
			GetRgbValues(out var r, out var g, out var b);
			int num = Math.Min(Math.Min(r, g), b);
			return (float)checked(Math.Max(Math.Max(r, g), b) + num) / 510f;
		}

		public float GetHue()
		{
			GetRgbValues(out var r, out var g, out var b);
			if (r == g && g == b)
			{
				return 0f;
			}
			int num = Math.Min(Math.Min(r, g), b);
			int num2 = Math.Max(Math.Max(r, g), b);
			checked
			{
				float num3 = num2 - num;
				float num4 = ((r == num2) ? ((float)(g - b) / num3) : ((g != num2) ? ((float)(r - g) / num3 + 4f) : ((float)(b - r) / num3 + 2f)));
				num4 *= 60f;
				if (num4 < 0f)
				{
					num4 += 360f;
				}
				return num4;
			}
		}

		public float GetSaturation()
		{
			GetRgbValues(out var r, out var g, out var b);
			if (r == g && g == b)
			{
				return 0f;
			}
			int num = Math.Min(Math.Min(r, g), b);
			int num2 = Math.Max(Math.Max(r, g), b);
			checked
			{
				int num3 = num2 + num;
				if (num3 > 255)
				{
					num3 = 510 - num2 - num;
				}
				return (float)(num2 - num) / (float)num3;
			}
		}

		public int ToArgb()
		{
			return (int)Value;
		}

		public override string ToString()
		{
			if ((state & 2) != 0)
			{
				return "ParameterColorValue [A=" + A + ", R=" + R + ", G=" + G + ", B=" + B + "]";
			}
			return "ParameterColorValue [Empty]";
		}

		public static bool operator ==(ParameterColorValue left, ParameterColorValue right)
		{
			if (left.value == right.value)
			{
				return left.state == right.state;
			}
			return false;
		}

		public static bool operator !=(ParameterColorValue left, ParameterColorValue right)
		{
			return !(left == right);
		}

		public override bool Equals(object? obj)
		{
			if (obj is ParameterColorValue other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(ParameterColorValue other)
		{
			return this == other;
		}

		public override int GetHashCode()
		{
			long num = value;
			int num2 = num.GetHashCode() * 397;
			short num3 = state;
			return num2 ^ num3.GetHashCode();
		}
	}
	public class ParameterValue<TValue> : ParameterBase, IParameterValue
	{
		[JsonProperty(PropertyName = "value")]
		public TValue? Value;

		[JsonIgnore]
		string IParameterValue.ID => ID;

		[JsonIgnore]
		string IParameterValue.Name => Name;

		[JsonIgnore]
		ParameterType IParameterValue.Type => Type;

		[JsonIgnore]
		object? IParameterValue.Value => Value;

		[JsonConstructor]
		public ParameterValue(string name, string id, TValue? value)
			: base(name, id, ParameterType.Options)
		{
			Value = value;
		}

		public override string ToString()
		{
			return Name;
		}
	}
	public class PlayerInfo : SimpleJSONRequest
	{
		public JObject? player;

		public PlayerInfo()
		{
			type = RequestType.PlayerInfo;
		}
	}
	[JsonConverter(typeof(Converter))]
	public class RequestParameters : IEnumerable<IParameterValue>, IEnumerable
	{
		private class Converter : JsonConverter<RequestParameters>
		{
			public override void WriteJson(JsonWriter writer, RequestParameters? value, JsonSerializer serializer)
			{
				serializer.Serialize(writer, (object)value?._parameters);
			}

			public override RequestParameters? ReadJson(JsonReader reader, Type objectType, RequestParameters? existingValue, bool hasExistingValue, JsonSerializer serializer)
			{
				JObject obj = JObject.Load(reader);
				List<IParameterValue> list = new List<IParameterValue>();
				foreach (KeyValuePair<string, JToken> item in obj)
				{
					string key = item.Key;
					string name = Extensions.Value<string>((IEnumerable<JToken>)item.Value[(object)"name"]);
					switch (Extensions.Value<ParameterBase.ParameterType>((IEnumerable<JToken>)item.Value[(object)"type"]))
					{
					case ParameterBase.ParameterType.Options:
					{
						string value = Extensions.Value<string>((IEnumerable<JToken>)item.Value[(object)"value"]);
						list.Add(new ParameterValue<string>(name, key, value));
						break;
					}
					case ParameterBase.ParameterType.HexColor:
					{
						if (HexColorConverter.TryParse(Extensions.Value<string>((IEnumerable<JToken>)item.Value[(object)"value"]), out var color))
						{
							list.Add(new ParameterColor(name, key, color));
						}
						break;
					}
					default:
						throw new SerializationException();
					}
				}
				return new RequestParameters(list);
			}
		}

		private readonly Dictionary<string, IParameterValue> _parameters;

		private readonly List<string> _parameter_list;

		public string this[int index] => _parameter_list[index];

		public IParameterValue this[string key] => _parameters[key];

		public IEnumerable<string> Keys => _parameters.Keys;

		public IEnumerable<IParameterValue> Values => _parameters.Values;

		public int Count => _parameters.Count;

		private RequestParameters()
		{
			_parameters = new Dictionary<string, IParameterValue>();
			_parameter_list = new List<string>();
		}

		public RequestParameters(IEnumerable<IParameterValue> parameters)
		{
			parameters = parameters.ToArray();
			_parameters = parameters.ToDictionary((IParameterValue d) => d.ID);
			_parameter_list = parameters.Select((IParameterValue v) => v.Value.ToString()).ToList();
		}

		public RequestParameters(IEnumerable<KeyValuePair<string, IParameterValue>> parameters)
		{
			_parameters = parameters.ToDictionary();
			_parameter_list = _parameters.Values.Select((IParameterValue p) => p.Value.ToString()).ToList();
		}

		public IEnumerator<IParameterValue> GetEnumerator()
		{
			return _parameters.Values.GetEnumerator();
		}

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

		public bool ContainsKey(string key)
		{
			return _parameters.ContainsKey(key);
		}

		public bool TryGetValue(string key, out IParameterValue value)
		{
			return _parameters.TryGetValue(key, out value);
		}

		public IEnumerable<string> Where(Func<string, bool> predicate)
		{
			return ((IEnumerable<string>)this).Where(predicate);
		}

		public IEnumerable<TResult> Select<TResult>(Func<string, TResult> selector)
		{
			return ((IEnumerable<string>)this).Select(selector);
		}

		public IEnumerable<TResult> SelectMany<TResult>(Func<string, IEnumerable<TResult>> selector)
		{
			return ((IEnumerable<string>)this).SelectMany(selector);
		}

		public IEnumerable<TResult> SelectMany<TResult>(Func<string, int, IEnumerable<TResult>> selector)
		{
			return ((IEnumerable<string>)this).SelectMany(selector);
		}

		public string First()
		{
			return ((IEnumerable<string>)this).First();
		}

		public string First(Func<string, bool> predicate)
		{
			return ((IEnumerable<string>)this).First(predicate);
		}

		public string? FirstOrDefault()
		{
			return ((IEnumerable<string>)this).FirstOrDefault();
		}

		public string FirstOrDefault(string defaultValue)
		{
			return ((IEnumerable<string>)this).FirstOrDefault() ?? defaultValue;
		}

		public string? FirstOrDefault(Func<string, bool> predicate)
		{
			return ((IEnumerable<string>)this).FirstOrDefault(predicate);
		}

		public string FirstOrDefault(Func<string, bool> predicate, string defaultValue)
		{
			return ((IEnumerable<string>)this).FirstOrDefault(predicate) ?? defaultValue;
		}

		public bool Any()
		{
			return ((IEnumerable<string>)this).Any();
		}

		public bool Any(Func<string, bool> predicate)
		{
			return ((IEnumerable<string>)this).Any(predicate);
		}
	}
	public enum RequestType : byte
	{
		[Obsolete("Use EffectTest instead.")]
		Test = 0,
		EffectTest = 0,
		[Obsolete("Use EffectStart instead.")]
		Start = 1,
		EffectStart = 1,
		[Obsolete("Use EffectStop instead.")]
		Stop = 2,
		EffectStop = 2,
		GenericEvent = 16,
		DataRequest = 32,
		RpcResponse = 208,
		PlayerInfo = 224,
		Login = 240,
		GameUpdate = 253,
		KeepAlive = byte.MaxValue
	}
	[JsonConverter(typeof(CamelCaseStringEnumConverter))]
	public enum ResponseType : byte
	{
		EffectRequest = 0,
		EffectStatus = 1,
		GenericEvent = 16,
		LoadEvent = 24,
		SaveEvent = 25,
		DataResponse = 32,
		RpcRequest = 208,
		Login = 240,
		LoginSuccess = 241,
		GameUpdate = 253,
		Disconnect = 254,
		KeepAlive = byte.MaxValue
	}
	public class RpcRequest : SimpleJSONResponse
	{
		public string? method;

		public object?[]? args;

		public RpcRequest()
		{
			type = ResponseType.RpcRequest;
		}
	}
	public class RpcResponse : SimpleJSONRequest
	{
		public object? value;

		public RpcResponse()
		{
			type = RequestType.RpcResponse;
		}
	}
	public abstract class SimpleJSONMessage
	{
		public static readonly JsonSerializerSettings JSON_SERIALIZER_SETTINGS = new JsonSerializerSettings
		{
			NullValueHandling = (NullValueHandling)1,
			MissingMemberHandling = (MissingMemberHandling)0,
			Formatting = (Formatting)0
		};

		public static readonly JsonSerializer JSON_SERIALIZER = new JsonSerializer
		{
			NullValueHandling = JSON_SERIALIZER_SETTINGS.NullValueHandling,
			MissingMemberHandling = JSON_SERIALIZER_SETTINGS.MissingMemberHandling,
			Formatting = JSON_SERIALIZER_SETTINGS.Formatting
		};

		private static int _next_id = 0;

		public static uint NextID
		{
			get
			{
				uint result;
				while ((result = (uint)Interlocked.Increment(ref _next_id)) == 0)
				{
				}
				return result;
			}
		}

		public abstract uint ID { get; }

		public abstract bool IsKeepAlive { get; }

		public string Serialize()
		{
			return JsonConvert.SerializeObject((object)this, JSON_SERIALIZER_SETTINGS);
		}
	}
	public class SimpleJSONRequest : SimpleJSONMessage
	{
		public uint id = SimpleJSONMessage.NextID;

		public RequestType type;

		[JsonIgnore]
		public override uint ID => id;

		[JsonIgnore]
		public override bool IsKeepAlive => type == RequestType.KeepAlive;

		public static bool TryParse(string json, out SimpleJSONRequest? request)
		{
			return TryParse(JObject.Parse(json), out request);
		}

		public static bool TryParse(JObject j, out SimpleJSONRequest? request)
		{
			try
			{
				JToken value = j.GetValue("type");
				RequestType requestType = ((value != null) ? ((RequestType)(object)CamelCaseStringEnumConverter.ReadJToken(value, typeof(RequestType))) : RequestType.Test);
				switch (requestType)
				{
				case RequestType.Stop:
					if (requestType != RequestType.Stop)
					{
						break;
					}
					request = ((JToken)j).ToObject<EffectRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.Test:
				case RequestType.Start:
					request = ((JToken)j).ToObject<EffectRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.DataRequest:
					request = ((JToken)j).ToObject<DataRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.RpcResponse:
					request = ((JToken)j).ToObject<RpcResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.PlayerInfo:
					request = ((JToken)j).ToObject<PlayerInfo>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.Login:
					request = ((JToken)j).ToObject<MessageRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.GameUpdate:
					request = ((JToken)j).ToObject<EmptyRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case RequestType.KeepAlive:
					request = ((JToken)j).ToObject<EmptyRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				}
			}
			catch
			{
			}
			request = null;
			return false;
		}
	}
	public class SimpleJSONResponse : SimpleJSONMessage
	{
		public uint id;

		public ResponseType type;

		[JsonIgnore]
		public override uint ID => id;

		[JsonIgnore]
		public override bool IsKeepAlive => type == ResponseType.KeepAlive;

		[JsonIgnore]
		public static SimpleJSONResponse KeepAlive { get; } = new EmptyResponse
		{
			type = ResponseType.KeepAlive
		};

		public static bool TryParse(string json, out SimpleJSONResponse? response)
		{
			return TryParse(JObject.Parse(json), out response);
		}

		public static bool TryParse(JObject j, out SimpleJSONResponse? response)
		{
			try
			{
				JToken value = j.GetValue("type");
				ResponseType responseType = ((value != null) ? ((ResponseType)(object)CamelCaseStringEnumConverter.ReadJToken(value, typeof(ResponseType))) : ResponseType.EffectRequest);
				switch (responseType)
				{
				case ResponseType.EffectStatus:
					if (responseType != ResponseType.EffectStatus)
					{
						break;
					}
					response = ((JToken)j).ToObject<EffectUpdate>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.EffectRequest:
					response = ((JToken)j).ToObject<EffectResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.RpcRequest:
					response = ((JToken)j).ToObject<RpcRequest>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.GenericEvent:
					response = ((JToken)j).ToObject<GenericEventResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.DataResponse:
					response = ((JToken)j).ToObject<DataResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.Login:
					response = ((JToken)j).ToObject<EmptyResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.LoginSuccess:
					response = ((JToken)j).ToObject<EmptyResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.GameUpdate:
					response = ((JToken)j).ToObject<GameUpdate>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.Disconnect:
					response = ((JToken)j).ToObject<MessageResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				case ResponseType.KeepAlive:
					response = ((JToken)j).ToObject<EmptyResponse>(SimpleJSONMessage.JSON_SERIALIZER);
					return true;
				}
			}
			catch
			{
			}
			response = null;
			return false;
		}
	}
	[JsonConverter(typeof(CamelCaseStringEnumConverter))]
	public enum StandardErrors
	{
		Unknown = 0,
		ExceptionThrown = 1,
		BadRequest = 4096,
		[Obsolete("Use EffectUnknown instead.")]
		UnknownEffect = 4097,
		EffectUnknown = 4097,
		EffectDisabled = 4098,
		AlreadyFailed = 4099,
		CannotParseNumber = 4112,
		UnknownSelection = 4113,
		ConnectorError = 8192,
		ConnectorReadFailure = 8193,
		ConnectorWriteFailure = 8194,
		ConnectorNotConnected = 8195,
		ConnectorNotSupported = 8196,
		SettingsError = 12288,
		CooldownPerEffect = 12545,
		CooldownGlobal = 12546,
		RetryMaxTime = 12291,
		RetryMaxAttempts = 12292,
		NoSession = 20480,
		SessionEnding = 20481,
		BadGameState = 16384,
		GameObjectNotFound = 16640,
		PlayerNotFound = 16641,
		CharacterNotFound = 16642,
		EnemyNotFound = 16643,
		ObjectNotFound = 16644,
		PrerequisiteNotFound = 16645,
		ObjectStateError = 16896,
		AlreadyInState = 16897,
		AlreadyAcquired = 16898,
		AlreadyFinished = 16899,
		NoEmptyContainers = 16912,
		PartyFull = 16913,
		InvalidArea = 16928,
		InvalidTarget = 16929,
		NoValidTargets = 16930,
		SpawnNotAllowedHere = 16932,
		RangeError = 17152,
		AlreadyMinimum = 17153,
		AlreadyMaximum = 17154,
		EffectNotImplemented = 24576,
		PackResourceMissing = 24577,
		ConflictingEffectRunning = 32768,
		UnqueueablePending = 32769,
		EmulatorNotSupported = 28672,
		EmulatorInvalidSetting = 28673
	}
	internal static class StringEx
	{
		public static bool IsNullOrWhiteSpace(this string? input)
		{
			if (input == null)
			{
				return true;
			}
			for (int i = 0; i < input.Length; i = checked(i + 1))
			{
				if (!char.IsWhiteSpace(input[i]))
				{
					return false;
				}
			}
			return true;
		}

		internal static string ToCamelCase(this string input)
		{
			bool flag = false;
			string text = "";
			checked
			{
				for (int i = 0; i < input.Length; i++)
				{
					if (char.IsUpper(input[i]))
					{
						if (flag)
						{
							text += input.Substring(i);
							break;
						}
						text += char.ToLower(input[i]);
					}
					else
					{
						flag = true;
						text = ((i <= 1 || !char.IsUpper(input[i - 1]) || !char.IsUpper(input[i - 2])) ? (text + input[i]) : (text.Substring(0, text.Length - 1) + char.ToUpper(input[i - 1]) + input[i]));
					}
				}
				return text;
			}
		}

		internal unsafe static string[] Chop(this string value, int chopLength)
		{
			int length = value.Length;
			char* ptr = stackalloc char[chopLength];
			string[] array = new string[length];
			for (int i = 0; i < length; i = checked(i + chopLength))
			{
				int j;
				for (j = 0; j < chopLength; j = checked(j + 1))
				{
					int num = checked(i + j);
					if (num >= length)
					{
						break;
					}
					*(char*)((byte*)ptr + checked(unchecked((nint)j) * (nint)2)) = value[num];
				}
				array[i / chopLength] = new string(ptr, 0, j);
			}
			return array;
		}
	}
}

BepInEx/plugins/CrowdControl/CrowdControl.Broforce.dll

Decompiled a day ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ConnectorLib.JSON;
using CrowdControl.Delegates.Effects;
using CrowdControl.Delegates.Metadata;
using CrowdControl.Harmony;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Networking;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	internal sealed class ParamCollectionAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[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]
	[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;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CrowdControl
{
	public static class BroHelper
	{
		private const float SCREEN_MARGIN = 0.15f;

		private const float FALLBACK_RADIUS = 420f;

		public static List<Player> LivingLocalPlayers()
		{
			List<Player> list = new List<Player>(4);
			try
			{
				Player[] players = HeroController.players;
				if (players == null)
				{
					return list;
				}
				for (int i = 0; i < players.Length; i = checked(i + 1))
				{
					Player val = players[i];
					if (ControlsSlot(i, val) && ((BroforceObject)val.character).IsAlive())
					{
						list.Add(val);
					}
				}
			}
			catch
			{
			}
			return list;
		}

		private static bool ControlsSlot(int index, Player player)
		{
			if ((Object)(object)player == (Object)null || !((NetworkObject)player).IsMine || (Object)(object)player.character == (Object)null)
			{
				return false;
			}
			if (CrowdControlNet.IsOnline())
			{
				return OwnsSlotOnline(index);
			}
			return true;
		}

		public static List<int> LocalSlots()
		{
			List<int> list = new List<int>(4);
			try
			{
				Player[] players = HeroController.players;
				if (players == null)
				{
					return list;
				}
				for (int i = 0; i < players.Length; i = checked(i + 1))
				{
					if (ControlsSlot(i, players[i]))
					{
						list.Add(i);
					}
				}
			}
			catch
			{
			}
			return list;
		}

		public static List<int> OwnedSlots()
		{
			List<int> list = new List<int>(4);
			try
			{
				Player[] players = HeroController.players;
				if (players == null)
				{
					return list;
				}
				for (int i = 0; i < players.Length; i = checked(i + 1))
				{
					Player val = players[i];
					if (!((Object)(object)val == (Object)null) && ((NetworkObject)val).IsMine && (!CrowdControlNet.IsOnline() || OwnsSlotOnline(i)))
					{
						list.Add(i);
					}
				}
			}
			catch
			{
			}
			return list;
		}

		public static bool OwnsSlot(int index)
		{
			try
			{
				Player[] players = HeroController.players;
				if (players == null || index < 0 || index >= players.Length)
				{
					return false;
				}
				Player val = players[index];
				if ((Object)(object)val == (Object)null || !((NetworkObject)val).IsMine)
				{
					return false;
				}
				return !CrowdControlNet.IsOnline() || OwnsSlotOnline(index);
			}
			catch
			{
				return false;
			}
		}

		private static bool OwnsSlotOnline(int index)
		{
			try
			{
				PID[] pIDS = HeroController.PIDS;
				if (pIDS == null || index >= pIDS.Length || pIDS[index] == (PID)null)
				{
					return true;
				}
				return pIDS[index].IsMine;
			}
			catch
			{
				return true;
			}
		}

		public static List<Unit> NearbyEnemies()
		{
			//IL_0006: 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)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			List<Unit> list = new List<Unit>();
			try
			{
				Rect val = ActiveArea();
				Unit[] array = Object.FindObjectsOfType<Unit>();
				foreach (Unit val2 in array)
				{
					if (!((Object)(object)val2 == (Object)null) && ((NetworkedUnit)val2).IsEnemy && ((BroforceObject)val2).IsAlive() && ((Rect)(ref val)).Contains(new Vector2(((BroforceObject)val2).X, ((BroforceObject)val2).Y)))
					{
						list.Add(val2);
					}
				}
			}
			catch
			{
			}
			return list;
		}

		private static Rect ActiveArea()
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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)
			//IL_007d: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				SortOfFollow instance = SortOfFollow.instance;
				float worldScreenWidth = SortOfFollow.GetWorldScreenWidth();
				float worldScreenHeight = SortOfFollow.GetWorldScreenHeight();
				if ((Object)(object)instance != (Object)null && worldScreenWidth > 0f && worldScreenHeight > 0f)
				{
					Vector3 position = ((Component)instance).transform.position;
					float num = worldScreenWidth * 0.5f * 1.15f;
					float num2 = worldScreenHeight * 0.5f * 1.15f;
					return new Rect(position.x - num, position.y - num2, num * 2f, num2 * 2f);
				}
			}
			catch
			{
			}
			List<Player> list = LivingLocalPlayers();
			if (list.Count == 0)
			{
				return new Rect(0f, 0f, 0f, 0f);
			}
			TestVanDammeAnim character = list[0].character;
			return new Rect(((BroforceObject)character).X - 420f, ((BroforceObject)character).Y - 420f, 840f, 840f);
		}

		public static List<Player> LocalPlayers()
		{
			List<Player> list = new List<Player>(4);
			try
			{
				Player[] players = HeroController.players;
				if (players == null)
				{
					return list;
				}
				for (int i = 0; i < players.Length; i = checked(i + 1))
				{
					if (ControlsSlot(i, players[i]))
					{
						list.Add(players[i]);
					}
				}
			}
			catch
			{
			}
			return list;
		}
	}
	public static class BroRevive
	{
		private const int MAX_PLAYERS = 4;

		private const int HERO_COUNT = 52;

		public static List<int> DeadSlots()
		{
			List<int> list = new List<int>(4);
			try
			{
				Player[] players = HeroController.players;
				if (players == null)
				{
					return list;
				}
				for (int i = 0; i < players.Length && i < 4; i = checked(i + 1))
				{
					Player val = players[i];
					if (!((Object)(object)val == (Object)null) && HeroController.IsPlaying(i) && !val.IsAlive())
					{
						list.Add(i);
					}
				}
			}
			catch
			{
			}
			return list;
		}

		public static bool ReviveLocal(int slot)
		{
			try
			{
				Player[] players = HeroController.players;
				if (players == null || slot < 0 || slot >= players.Length)
				{
					return false;
				}
				Player val = players[slot];
				if ((Object)(object)val == (Object)null || val.IsAlive())
				{
					return false;
				}
				if (!BroHelper.OwnsSlot(slot))
				{
					return false;
				}
				if (val.Lives <= 0)
				{
					val.AddLife();
				}
				val.SpawnHero((HeroType)NonDeterministicRandom.Range(0, 52));
				return true;
			}
			catch (Exception arg)
			{
				CrowdControlMod.Instance.Logger.LogError((object)$"Crowd Control could not revive player {slot}: {arg}");
				return false;
			}
		}
	}
	public static class CcTheme
	{
		public static readonly Color Slate800 = Hex(1709866);

		public static readonly Color Slate600 = Hex(2632003);

		public static readonly Color Slate500 = Hex(2961485);

		public static readonly Color Royal50 = Hex(7764980);

		public static readonly Color White100 = Hex(16448250);

		public static readonly Color White200 = Hex(13487593);

		public static readonly Color White300 = Hex(11184845);

		public static readonly Color Teal200 = Hex(2024093);

		public static readonly Color Red200 = Hex(15351146);

		public static readonly Color Yellow300 = Hex(16754437);

		public static readonly Color Blurple200 = Hex(4239863);

		private static Color Hex(int rgb, float a = 1f)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			return new Color((float)((rgb >> 16) & 0xFF) / 255f, (float)((rgb >> 8) & 0xFF) / 255f, (float)(rgb & 0xFF) / 255f, a);
		}

		public static Color Fade(this Color c, float alpha)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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)
			return new Color(c.r, c.g, c.b, c.a * alpha);
		}
	}
	[BepInPlugin("WarpWorld.CrowdControl.Broforce", "Crowd Control for Broforce", "1.5.0.0")]
	public class CrowdControlMod : BaseUnityPlugin
	{
		public const string MOD_GUID = "WarpWorld.CrowdControl.Broforce";

		public const string MOD_NAME = "Crowd Control for Broforce";

		public const string MOD_VERSION = "1.5.0.0";

		private readonly Harmony harmony = new Harmony("WarpWorld.CrowdControl.Broforce");

		private const double MANUAL_RECONNECT_COOLDOWN_SECONDS = 5.0;

		private const float STATE_HEARTBEAT_SECONDS = 5f;

		private const float SESSION_GRACE_SECONDS = 20f;

		private float m_sessionGrace;

		private DateTime m_nextManualReconnectAllowedUtc = DateTime.MinValue;

		private float m_heartbeatTimer;

		private bool m_wasConnected;

		private bool m_initialized;

		public static float DeltaTime
		{
			get
			{
				if (!(Time.timeScale > 0f))
				{
					return 0f;
				}
				return Time.unscaledDeltaTime;
			}
		}

		public ManualLogSource Logger => ((BaseUnityPlugin)this).Logger;

		internal static CrowdControlMod Instance { get; private set; }

		public ModConfig Settings { get; private set; }

		public Overlay Overlay { get; private set; }

		public GameStateManager GameStateManager { get; private set; }

		public EffectLoader EffectLoader { get; private set; }

		public bool ClientConnected => Client?.Connected ?? false;

		public NetworkClient Client { get; private set; }

		public Scheduler Scheduler { get; private set; }

		private void Awake()
		{
			Instance = this;
			try
			{
				((Component)this).gameObject.tag = "Unpausable";
			}
			catch
			{
			}
			try
			{
				PauseComponent obj2 = ((Component)this).gameObject.AddComponent<PauseComponent>();
				obj2.PauseOnMenu = false;
				obj2.PauseOnCutscene = false;
			}
			catch
			{
			}
			Logger.LogInfo((object)"Loaded WarpWorld.CrowdControl.Broforce v1.5.0.0. Patching.");
			CrowdControlNet.InstallAssemblyResolver();
			try
			{
				harmony.PatchAll();
			}
			catch (Exception arg)
			{
				Logger.LogError((object)$"Crowd Control Harmony patching failed - input effects will not work: {arg}");
			}
			Logger.LogInfo((object)"Initializing Crowd Control");
			try
			{
				Settings = new ModConfig(((BaseUnityPlugin)this).Config);
				Overlay = new Overlay(Settings);
				GameStateManager = new GameStateManager(this);
				Client = new NetworkClient(this);
				EffectLoader = new EffectLoader(this, Client);
				Scheduler = new Scheduler(this, Client);
				m_initialized = true;
				Logger.LogInfo((object)$"Crowd Control initialized with {EffectLoader.Effects.Count} effects.");
				CrowdControlNet.RunSelfTest();
			}
			catch (Exception arg2)
			{
				Logger.LogError((object)$"Crowd Control Init Error - the mod is disabled for this session: {arg2}");
			}
		}

		private void OnApplicationQuit()
		{
			Shutdown();
		}

		private void OnDestroy()
		{
			Shutdown();
		}

		private void Shutdown()
		{
			try
			{
				Scheduler?.StopAll("The game is shutting down.");
			}
			catch
			{
			}
			try
			{
				EffectCleanup.ResetAll();
			}
			catch
			{
			}
			try
			{
				MultiplayerState.Reset();
			}
			catch
			{
			}
			try
			{
				PendingReposition.Clear();
			}
			catch
			{
			}
			try
			{
				SharedVisuals.Reset();
			}
			catch
			{
			}
			try
			{
				CrowdControlNet.UninstallAssemblyResolver();
			}
			catch
			{
			}
			try
			{
				Overlay?.Dispose();
			}
			catch
			{
			}
			try
			{
				Client?.Stop();
				Client?.Dispose();
			}
			catch
			{
			}
			try
			{
				harmony.UnpatchSelf();
			}
			catch
			{
			}
		}

		private void Update()
		{
			if (m_initialized)
			{
				HandleManualReconnectHotkey();
				HandleDiagnosticsHotkey();
				HandleConnectionStateChanges();
				EffectCleanup.Tick();
				PendingReposition.Tick();
				SharedVisuals.Tick();
				MultiplayerState.Tick();
				Overlay.ClientPresent = Client.CrowdControlClientFound;
				Overlay.MultiplayerWarning = MultiplayerState.StatusMessage;
				Overlay.EffectSourceDescription = MultiplayerState.EffectSourceDescription;
				GameStateManager.InvalidateStateCache();
				m_heartbeatTimer += Time.unscaledDeltaTime;
				bool flag = m_heartbeatTimer >= 5f;
				if (flag)
				{
					m_heartbeatTimer = 0f;
				}
				GameStateManager.UpdateGameState(flag);
				Scheduler.Tick();
			}
		}

		private void OnGUI()
		{
			if (!m_initialized)
			{
				return;
			}
			try
			{
				Overlay.Draw();
			}
			catch (Exception arg)
			{
				Logger.LogError((object)$"Crowd Control overlay error: {arg}");
			}
		}

		private void HandleConnectionStateChanges()
		{
			bool clientConnected = ClientConnected;
			if (clientConnected != m_wasConnected)
			{
				m_wasConnected = clientConnected;
				if (clientConnected)
				{
					Logger.LogInfo((object)"Crowd Control connected.");
					Overlay.ShowMessage("Crowd Control connected!");
				}
				else
				{
					Logger.LogWarning((object)"Crowd Control disconnected - stopping all active effects.");
					Overlay.ShowMessage("Crowd Control disconnected.");
					Scheduler.StopAll("The Crowd Control connection was lost.");
					EffectCleanup.ResetAll();
				}
			}
			Overlay.ConnectionStatus = ResolveStatus(clientConnected);
		}

		private Overlay.Status ResolveStatus(bool connected)
		{
			if (connected)
			{
				return CrowdControl.Overlay.Status.Connected;
			}
			if (Client.HasEverConnected)
			{
				return CrowdControl.Overlay.Status.Disconnected;
			}
			m_sessionGrace += Time.unscaledDeltaTime;
			if (m_sessionGrace < 20f && Client.CrowdControlClientFound)
			{
				return CrowdControl.Overlay.Status.Connecting;
			}
			return CrowdControl.Overlay.Status.NoSession;
		}

		private void HandleDiagnosticsHotkey()
		{
			//IL_000b: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			KeyCode value = Settings.DiagnosticsHotkey.Value;
			if ((int)value != 0 && Input.GetKeyDown(value))
			{
				Overlay.DisplayMode displayMode = Overlay.CycleMode();
				Logger.LogInfo((object)$"Crowd Control overlay: {displayMode}.");
				if (displayMode == CrowdControl.Overlay.DisplayMode.Diagnostics)
				{
					MultiplayerState.LogRoster();
				}
			}
		}

		private void HandleManualReconnectHotkey()
		{
			//IL_000b: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			KeyCode value = Settings.ReconnectHotkey.Value;
			if ((int)value == 0 || !Input.GetKeyDown(value))
			{
				return;
			}
			DateTime utcNow = DateTime.UtcNow;
			if (!(utcNow < m_nextManualReconnectAllowedUtc))
			{
				m_nextManualReconnectAllowedUtc = utcNow.AddSeconds(5.0);
				Logger.LogInfo((object)$"{value} pressed - manual Crowd Control reconnect requested.");
				if (Client.Connected)
				{
					ShowGameUiMessage("Crowd Control is already connected.");
				}
				else if (Client.RequestReconnect())
				{
					ShowGameUiMessage("Reconnecting to Crowd Control...");
					Logger.LogInfo((object)"Manual Crowd Control reconnect queued.");
				}
				else
				{
					ShowGameUiMessage("Crowd Control client not found - is the app running?");
					Logger.LogInfo((object)"Manual Crowd Control reconnect skipped because the Crowd Control client was not found.");
				}
			}
		}

		public void ShowGameUiMessage(string message)
		{
			Overlay?.ShowMessage(message);
		}

		private void OnApplicationFocus(bool hasFocus)
		{
			try
			{
				GameStateManager?.InvalidateStateCache();
				GameStateManager?.UpdateGameState();
			}
			catch
			{
			}
		}

		private void OnApplicationPause(bool isPaused)
		{
			try
			{
				GameStateManager?.InvalidateStateCache();
				GameStateManager?.UpdateGameState();
			}
			catch
			{
			}
		}
	}
	public static class CrowdControlNet
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static ResolveEventHandler <0>__ResolveModAssembly;

			public static RpcSignature<int, string, bool> <1>__Hello;

			public static RpcSignature<float, float, float, float> <2>__FreezeArea;

			public static RpcSignature <3>__ThawArea;

			public static RpcSignature<int, float, float> <4>__PlayExplosion;

			public static RpcSignature<int, bool> <5>__SetButterFloor;

			public static RpcSignature<int> <6>__ReviveSlot;
		}

		private const string RESOLVED_ASSEMBLY_NAME = "CrowdControl";

		private static bool m_resolverInstalled;

		public static bool SelfTestPassed { get; private set; }

		public static void InstallAssemblyResolver()
		{
			if (!m_resolverInstalled)
			{
				m_resolverInstalled = true;
				AppDomain.CurrentDomain.AssemblyResolve += ResolveModAssembly;
			}
		}

		public static void UninstallAssemblyResolver()
		{
			if (m_resolverInstalled)
			{
				m_resolverInstalled = false;
				AppDomain.CurrentDomain.AssemblyResolve -= ResolveModAssembly;
			}
		}

		private static Assembly? ResolveModAssembly(object sender, ResolveEventArgs args)
		{
			try
			{
				if (!string.Equals(new AssemblyName(args.Name).Name, "CrowdControl", StringComparison.OrdinalIgnoreCase))
				{
					return null;
				}
				return typeof(CrowdControlNet).Assembly;
			}
			catch
			{
				return null;
			}
		}

		public static bool RunSelfTest()
		{
			bool flag = true;
			string fullName = typeof(CrowdControlNet).FullName;
			try
			{
				if ((object)Assembly.Load("CrowdControl")?.GetType(fullName) != typeof(CrowdControlNet))
				{
					CrowdControlMod.Instance.Logger.LogError((object)("Crowd Control multiplayer self-test FAILED: a peer could not resolve \"" + fullName + "\". Networked effects will silently do nothing. Check the AssemblyResolve hook."));
					flag = false;
				}
			}
			catch (Exception ex)
			{
				CrowdControlMod.Instance.Logger.LogError((object)("Crowd Control multiplayer self-test FAILED resolving \"" + fullName + "\": " + ex.Message));
				flag = false;
			}
			try
			{
				if (!RPCSecurity.IsAllowed(typeof(CrowdControlNet), "Hello"))
				{
					CrowdControlMod.Instance.Logger.LogError((object)"Crowd Control multiplayer self-test FAILED: RPCSecurity rejected CrowdControlNet.Hello. The [AllowedRPC] attribute is missing or the method is not public static.");
					flag = false;
				}
			}
			catch (Exception ex2)
			{
				CrowdControlMod.Instance.Logger.LogError((object)("Crowd Control multiplayer self-test FAILED checking RPC permissions: " + ex2.Message));
				flag = false;
			}
			if (flag)
			{
				CrowdControlMod.Instance.Logger.LogInfo((object)"Crowd Control multiplayer self-test passed - mod RPCs are deliverable.");
			}
			SelfTestPassed = flag;
			return flag;
		}

		public static void BroadcastHello()
		{
			if (!IsOnline())
			{
				return;
			}
			try
			{
				bool clientConnected = CrowdControlMod.Instance.ClientConnected;
				Networking.RPC<int, string, bool>(PID.TargetOthers, (RpcSignature<int, string, bool>)Hello, PID.MyID.AsInt, "1.5.0.0", clientConnected, false);
			}
			catch (Exception arg)
			{
				CrowdControlMod.Instance.Logger.LogError((object)$"Crowd Control failed to announce itself to peers: {arg}");
			}
		}

		[AllowedRPC]
		public static void Hello(int senderId, string version, bool hasSession)
		{
			try
			{
				MultiplayerState.OnHello(senderId, version, hasSession);
			}
			catch (Exception arg)
			{
				CrowdControlMod.Instance.Logger.LogError((object)$"Crowd Control error handling a peer announcement: {arg}");
			}
		}

		public static int BroadcastFreeze(float x, float y, float radius, float seconds)
		{
			int result = EnemyFreeze.FreezeArea(x, y, radius, seconds);
			Send(delegate
			{
				Networking.RPC<float, float, float, float>(PID.TargetOthers, (RpcSignature<float, float, float, float>)FreezeArea, x, y, radius, seconds, false);
			}, "FreezeArea");
			return result;
		}

		public static void BroadcastThaw()
		{
			EnemyFreeze.Thaw();
			Send(delegate
			{
				//IL_0015: 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_0020: Expected O, but got Unknown
				PID targetOthers = PID.TargetOthers;
				object obj = <>O.<3>__ThawArea;
				if (obj == null)
				{
					RpcSignature val = ThawArea;
					<>O.<3>__ThawArea = val;
					obj = (object)val;
				}
				Networking.RPC(targetOthers, (RpcSignature)obj, false);
			}, "ThawArea");
		}

		[AllowedRPC]
		public static void FreezeArea(float x, float y, float radius, float seconds)
		{
			try
			{
				EnemyFreeze.FreezeArea(x, y, radius, seconds);
			}
			catch (Exception arg)
			{
				CrowdControlMod.Instance.Logger.LogError((object)$"Crowd Control error applying a relayed freeze: {arg}");
			}
		}

		[AllowedRPC]
		public static void ThawArea()
		{
			try
			{
				EnemyFreeze.Thaw();
			}
			catch (Exception arg)
			{
				CrowdControlMod.Instance.Logger.LogError((object)$"Crowd Control error applying a relayed thaw: {arg}");
			}
		}

		public static void BroadcastExplosion(SharedVisuals.ExplosionKind kind, float x, float y)
		{
			SharedVisuals.PlayExplosion(kind, x, y);
			Send(delegate
			{
				Networking.RPC<int, float, float>(PID.TargetOthers, (RpcSignature<int, float, float>)PlayExplosion, (int)kind, x, y, false);
			}, "PlayExplosion");
		}

		[AllowedRPC]
		public static void PlayExplosion(int kind, float x, float y)
		{
			try
			{
				SharedVisuals.PlayExplosion((SharedVisuals.ExplosionKind)kind, x, y);
			}
			catch (Exception arg)
			{
				CrowdControlMod.Instance.Logger.LogError((object)$"Crowd Control error drawing a relayed explosion: {arg}");
			}
		}

		public static void BroadcastButterFloor(int slot, bool active)
		{
			Send(delegate
			{
				Networking.RPC<int, bool>(PID.TargetOthers, (RpcSignature<int, bool>)SetButterFloor, slot, active, false);
			}, "SetButterFloor");
		}

		[AllowedRPC]
		public static void SetButterFloor(int slot, bool active)
		{
			try
			{
				SharedVisuals.SetButterFloor(slot, active);
			}
			catch (Exception arg)
			{
				CrowdControlMod.Instance.Logger.LogError((object)$"Crowd Control error applying a relayed butter floor: {arg}");
			}
		}

		public static void BroadcastRevive(int slot)
		{
			Send(delegate
			{
				Networking.RPC<int>(PID.TargetOthers, (RpcSignature<int>)ReviveSlot, slot, false);
			}, "ReviveSlot");
		}

		[AllowedRPC]
		public static void ReviveSlot(int slot)
		{
			try
			{
				if (BroRevive.ReviveLocal(slot))
				{
					CrowdControlMod.Instance.Logger.LogInfo((object)$"[Crowd Control MP] Revived player {slot} at another player's request.");
				}
			}
			catch (Exception arg)
			{
				CrowdControlMod.Instance.Logger.LogError((object)$"Crowd Control error handling a relayed revive: {arg}");
			}
		}

		private static void Send(Action send, string name)
		{
			if (!IsOnline())
			{
				return;
			}
			try
			{
				send();
			}
			catch (Exception arg)
			{
				CrowdControlMod.Instance.Logger.LogError((object)$"Crowd Control failed to broadcast {name}: {arg}");
			}
		}

		public static bool IsOnline()
		{
			try
			{
				return Connect.LayerExists && !Connect.IsOffline;
			}
			catch
			{
				return false;
			}
		}
	}
	public class DelimitedStreamReader(NetworkStream stream) : IDisposable
	{
		private readonly MemoryStream _memory_stream = new MemoryStream();

		private const int MAX_MESSAGE_SIZE = 1048576;

		~DelimitedStreamReader()
		{
			Dispose(disposing: false);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!disposing)
			{
				return;
			}
			try
			{
				_memory_stream.Dispose();
			}
			catch
			{
			}
		}

		public string ReadUntilNullTerminator()
		{
			int num;
			while ((num = stream.ReadByte()) != -1 && num != 0)
			{
				if (_memory_stream.Length >= 1048576)
				{
					_memory_stream.SetLength(0L);
					throw new InvalidDataException("Message exceeded the maximum allowed size without a null terminator. Dropping the connection.");
				}
				_memory_stream.WriteByte(checked((byte)num));
			}
			if (num == -1)
			{
				throw new EndOfStreamException("Reached end of stream without finding a null terminator.");
			}
			string result = Encoding.UTF8.GetString(_memory_stream.ToArray());
			_memory_stream.SetLength(0L);
			return result;
		}
	}
	public static class EffectCleanup
	{
		private const int RESTORE_HOLD_FRAMES = 30;

		private static bool m_restorePending;

		private static int m_restoreFramesLeft;

		public static void ResetAll()
		{
			InputPatches.ResetAll();
			RestoreTimeScale();
			GlobalEffectState.Reset();
			try
			{
				EnemyFreeze.Thaw();
			}
			catch
			{
			}
			try
			{
				SharedVisuals.Reset();
			}
			catch
			{
			}
			try
			{
				PendingReposition.Clear();
			}
			catch
			{
			}
		}

		public static void RestoreTimeScale()
		{
			try
			{
				if (PauseController.Paused)
				{
					m_restorePending = true;
					m_restoreFramesLeft = 30;
				}
				else
				{
					m_restorePending = false;
					m_restoreFramesLeft = 0;
					Time.timeScale = 1f;
				}
			}
			catch
			{
			}
		}

		public static void Tick()
		{
			if (!m_restorePending)
			{
				return;
			}
			try
			{
				if (!PauseController.Paused)
				{
					Time.timeScale = 1f;
					if (checked(--m_restoreFramesLeft) <= 0)
					{
						m_restorePending = false;
					}
				}
			}
			catch
			{
				m_restorePending = false;
			}
		}
	}
	public static class EffectNames
	{
		private static readonly Dictionary<string, string> NAMES = new Dictionary<string, string>
		{
			{ "swap_bro", "Swap Bro" },
			{ "revive_bro", "Revive" },
			{ "god_mode", "God Mode" },
			{ "infinite_ammo", "Infinite Ammo" },
			{ "give_ammo", "Special Ammo Refill" },
			{ "moon_jump", "Moon Jump" },
			{ "heavy_boots", "Heavy Boots" },
			{ "speed_demon", "Speed Demon" },
			{ "butter_floor", "Butter Floor" },
			{ "invert_controls", "Inverted Controls" },
			{ "butter_fingers", "Butter Fingers" },
			{ "pacifism", "Pacifism" },
			{ "freeze_enemies", "Ice Age" },
			{ "kill_enemies", "Airstrike" },
			{ "mook_rain", "Mook Rain" },
			{ "spawn_tank", "Rocket Tank" },
			{ "spawn_copter", "Attack Helicopter" },
			{ "slow_motion", "Slow Motion" },
			{ "fast_forward", "Fast Forward" },
			{ "event-hype-train", "the Hype Train" },
			{ "nuke_player", "Nuke" },
			{ "earthquake", "Earthquake" },
			{ "explosive_steps", "Explosive Footsteps" },
			{ "armageddon", "Armageddon" }
		};

		public static string Describe(string? code)
		{
			if (string.IsNullOrEmpty(code))
			{
				return "an effect";
			}
			if (!NAMES.TryGetValue(code, out string value))
			{
				return Prettify(code);
			}
			return value;
		}

		private static string Prettify(string code)
		{
			StringBuilder stringBuilder = new StringBuilder(code.Length);
			bool flag = true;
			foreach (char c in code)
			{
				if ((c == '-' || c == '_') ? true : false)
				{
					stringBuilder.Append(' ');
					flag = true;
				}
				else
				{
					stringBuilder.Append(flag ? char.ToUpperInvariant(c) : c);
					flag = false;
				}
			}
			return stringBuilder.ToString();
		}
	}
	public static class EffectRequestEx
	{
		public const string DEFAULT_VIEWER_NAME = "the crowd";

		public const int MAX_VIEWER_NAME_LENGTH = 32;

		public static string GetViewerDisplayName(this EffectRequest request, string fallback = "the crowd")
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Invalid comparison between Unknown and I4
			string text = request.viewer;
			if (IsNullOrWhiteSpace(text) && request.viewers != null)
			{
				foreach (JToken viewer in request.viewers)
				{
					JToken obj = ((viewer is JObject) ? viewer : null);
					string text2 = ((obj != null) ? obj.Value<string>((object)"name") : null);
					if (text2 == null)
					{
						string text3 = (((int)viewer.Type != 8) ? null : Extensions.Value<string>((IEnumerable<JToken>)viewer));
						text2 = text3;
					}
					text = text2;
					if (!IsNullOrWhiteSpace(text))
					{
						break;
					}
				}
			}
			string text4 = SanitizeDisplayName(text);
			if (text4.Length <= 0)
			{
				return fallback;
			}
			return text4;
		}

		public static string SanitizeDisplayName(string? name)
		{
			if (IsNullOrWhiteSpace(name))
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(Math.Min(name.Length, 32));
			bool flag = true;
			foreach (char c in name)
			{
				if (char.IsControl(c) || char.IsSurrogate(c) || ((c == '<' || c == '>') ? true : false))
				{
					continue;
				}
				if (char.IsWhiteSpace(c))
				{
					if (flag)
					{
						continue;
					}
					stringBuilder.Append(' ');
					flag = true;
				}
				else
				{
					stringBuilder.Append(c);
					flag = false;
				}
				if (stringBuilder.Length >= 32)
				{
					break;
				}
			}
			return stringBuilder.ToString().TrimEnd(new char[0]);
		}

		private static bool IsNullOrWhiteSpace(string? value)
		{
			if (!string.IsNullOrEmpty(value))
			{
				return value.Trim().Length == 0;
			}
			return true;
		}
	}
	public static class EnemyFreeze
	{
		private static readonly List<TestVanDammeAnim> m_frozen = new List<TestVanDammeAnim>();

		public static int Count => m_frozen.Count;

		public static int FreezeArea(float x, float y, float radius, float seconds)
		{
			Thaw();
			float num = radius * radius;
			Unit[] array = Object.FindObjectsOfType<Unit>();
			foreach (Unit val in array)
			{
				if ((Object)(object)val == (Object)null || !((NetworkedUnit)val).IsEnemy || !((BroforceObject)val).IsAlive())
				{
					continue;
				}
				TestVanDammeAnim val2 = (TestVanDammeAnim)(object)((val is TestVanDammeAnim) ? val : null);
				if (val2 == null || !((Unit)val2).CanFreeze())
				{
					continue;
				}
				float num2 = ((BroforceObject)val).X - x;
				float num3 = ((BroforceObject)val).Y - y;
				if (!(num2 * num2 + num3 * num3 > num))
				{
					try
					{
						((Unit)val2).Freeze(seconds);
						m_frozen.Add(val2);
					}
					catch
					{
					}
				}
			}
			return m_frozen.Count;
		}

		public static void Thaw()
		{
			foreach (TestVanDammeAnim item in m_frozen)
			{
				if (!((Object)(object)item == (Object)null))
				{
					try
					{
						item.UnFreeze();
					}
					catch
					{
					}
				}
			}
			m_frozen.Clear();
		}
	}
	public class GameStateManager(CrowdControlMod mod)
	{
		public const bool CARE_ABOUT_FOCUS = true;

		private GameState? m_cachedState;

		private volatile bool m_stateResendRequested;

		private GameState? _last_game_state;

		private bool AllowOnlineMultiplayer
		{
			get
			{
				try
				{
					return mod.Settings.AllowOnlineMultiplayer.Value;
				}
				catch
				{
					return false;
				}
			}
		}

		public GameState CurrentState
		{
			get
			{
				//IL_0006: 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)
				//IL_002e: 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)
				GameState valueOrDefault = m_cachedState.GetValueOrDefault();
				if (!m_cachedState.HasValue)
				{
					valueOrDefault = GetGameState();
					m_cachedState = valueOrDefault;
					return valueOrDefault;
				}
				return valueOrDefault;
			}
		}

		public bool IsReady(string code = "")
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			return (int)CurrentState == 1;
		}

		public GameState GetGameState()
		{
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!Application.isFocused)
				{
					return (GameState)(-5);
				}
				if (PauseController.Paused)
				{
					return (GameState)(-7);
				}
				if (CutsceneController.InCutscene)
				{
					return (GameState)(-11);
				}
				if ((Object)(object)Map.Instance == (Object)null || !Map.Instance.HasBeenSetup)
				{
					Scene activeScene = SceneManager.GetActiveScene();
					string name = ((Scene)(ref activeScene)).name;
					if (name == "newJoin" || name.Contains("Join") || name == "HeroSelect" || name == "DifficultyMenu")
					{
						return (GameState)(-13);
					}
					if ((Object)(object)MainMenu.instance != (Object)null || name == "MainMenu" || name == "newMainMenu")
					{
						return (GameState)(-13);
					}
					if ((Object)(object)WorldMapController.instance != (Object)null || name == "WorldMap3D" || name == "WorldMap" || name.Contains("Map"))
					{
						return (GameState)(-8);
					}
					return (GameState)(-6);
				}
				if (HeroController.players == null)
				{
					return (GameState)(-6);
				}
				bool flag = false;
				for (int i = 0; i < 4; i = checked(i + 1))
				{
					if ((Object)(object)HeroController.players[i] != (Object)null && HeroController.players[i].IsAlive())
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					return (GameState)(-12);
				}
				return (GameState)1;
			}
			catch (Exception ex)
			{
				CrowdControlMod.Instance.Logger.LogError((object)("ERROR in GetGameState: " + ex.ToString()));
				return (GameState)(-1);
			}
		}

		public bool IsEffectAvailable(Effect effect, out string? reason)
		{
			reason = null;
			if (!IsOnlineSession())
			{
				return true;
			}
			if (effect.OnlineSupport == OnlineSupport.Supported)
			{
				return true;
			}
			if (AllowOnlineMultiplayer)
			{
				return true;
			}
			reason = "This effect isn't supported in online multiplayer yet.";
			return false;
		}

		private static bool IsOnlineSession()
		{
			try
			{
				return Connect.LayerExists && !Connect.IsOffline;
			}
			catch
			{
				return false;
			}
		}

		public string? DescribeCurrentState()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return Describe(CurrentState);
		}

		public static string? Describe(GameState state)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected I4, but got Unknown
			return (state - -13) switch
			{
				14 => null, 
				6 => "The game is paused.", 
				8 => "The game window is not focused.", 
				7 => "The game is loading.", 
				0 => "The streamer is in a menu.", 
				2 => "A cutscene is playing.", 
				1 => "The bro is dead or respawning.", 
				5 => "The streamer is on the world map.", 
				12 => "The mod hit an error reading the game state. Check the BepInEx log.", 
				_ => "The game is not ready for effects right now.", 
			};
		}

		public void InvalidateStateCache()
		{
			m_cachedState = null;
		}

		public void RequestStateResend()
		{
			m_stateResendRequested = true;
		}

		public bool UpdateGameState(bool force = false)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return UpdateGameState(CurrentState, force);
		}

		public bool UpdateGameState(GameState newState, bool force)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return UpdateGameState(newState, null, force);
		}

		public bool UpdateGameState(GameState newState, string? message = null, bool force = false)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if (m_stateResendRequested)
			{
				m_stateResendRequested = false;
				force = true;
			}
			bool flag = _last_game_state != (GameState?)newState;
			if (force || flag)
			{
				if (flag)
				{
					ManualLogSource logger = mod.Logger;
					ref GameState? last_game_state = ref _last_game_state;
					logger.LogInfo((object)string.Format("[Crowd Control] Game state: {0} -> {1}", (last_game_state.HasValue ? ((object)last_game_state.GetValueOrDefault()/*cast due to .constrained prefix*/).ToString() : null) ?? "(none)", newState));
				}
				_last_game_state = newState;
				return mod.Client.Send((SimpleJSONResponse?)new GameUpdate(newState, message));
			}
			return true;
		}
	}
	public static class GlobalEffectState
	{
		private static int m_invulnerabilityHolders;

		public static bool InvulnerabilityHeld => m_invulnerabilityHolders > 0;

		public static void AcquireInvulnerability()
		{
			checked
			{
				m_invulnerabilityHolders++;
				try
				{
					HeroController.forceInvulnerability = true;
				}
				catch
				{
				}
			}
		}

		public static void ReleaseInvulnerability()
		{
			checked
			{
				if (m_invulnerabilityHolders > 0)
				{
					m_invulnerabilityHolders--;
				}
				if (m_invulnerabilityHolders > 0)
				{
					return;
				}
				try
				{
					HeroController.forceInvulnerability = false;
				}
				catch
				{
				}
			}
		}

		public static void Reset()
		{
			m_invulnerabilityHolders = 0;
			try
			{
				HeroController.forceInvulnerability = false;
			}
			catch
			{
			}
		}
	}
	public class HypeTrainAnimation
	{
		private const float DURATION = 10f;

		private const int MAX_CARS = 5;

		private const float LOCO_WIDTH = 132f;

		private const float LOCO_HEIGHT = 62f;

		private const float CAR_HEIGHT = 48f;

		private const float CAR_MIN_WIDTH = 96f;

		private const float CAR_TEXT_PADDING = 14f;

		private const float COUPLING = 10f;

		private const float WHEEL_SIZE = 15f;

		private const float TRACK_HEIGHT = 4f;

		private const int CAR_FONT_SIZE = 13;

		private const int BANNER_FONT_SIZE = 20;

		private const float TRACK_Y_FRACTION = 0.62f;

		private const float SMOKE_SPACING = 46f;

		private const int SMOKE_PUFFS = 14;

		private const float HIGHLIGHT_FRACTION = 0.16f;

		private const float SHADE_FRACTION = 0.24f;

		private const float HIGHLIGHT_STRENGTH = 0.32f;

		private const float SHADE_STRENGTH = 0.42f;

		private static readonly Color OUTLINE = new Color(0.06f, 0.05f, 0.06f, 1f);

		private static readonly Color LOCO_BODY = new Color(0.68f, 0.18f, 0.15f, 1f);

		private static readonly Color CAB = new Color(0.34f, 0.31f, 0.29f, 1f);

		private static readonly Color CHIMNEY = new Color(0.26f, 0.24f, 0.23f, 1f);

		private static readonly Color CAR_BODY = new Color(0.47f, 0.44f, 0.22f, 1f);

		private static readonly Color NAME_PLATE = new Color(0.88f, 0.84f, 0.62f, 1f);

		private static readonly Color WHEEL = new Color(0.17f, 0.16f, 0.16f, 1f);

		private static readonly Color WHEEL_HUB = new Color(0.62f, 0.58f, 0.48f, 1f);

		private static readonly Color TRIM = new Color(0.96f, 0.8f, 0.25f, 1f);

		private static readonly Color WINDOW = new Color(0.3f, 0.55f, 0.62f, 1f);

		private static readonly Color TRACK = new Color(0.2f, 0.18f, 0.17f, 0.8f);

		private static readonly Color SMOKE = new Color(0.92f, 0.92f, 0.9f, 1f);

		private static readonly Color GROUND_SHADOW = new Color(0f, 0f, 0f, 0.3f);

		private static readonly Color PLATE_TEXT = new Color(0.13f, 0.11f, 0.09f, 1f);

		private string[] m_carLabels = new string[0];

		private string m_banner = string.Empty;

		private float m_startedAt = float.NegativeInfinity;

		private GUIStyle? m_carStyle;

		private GUIStyle? m_bannerStyle;

		private float m_line = 1f;

		public bool Active => Time.realtimeSinceStartup - m_startedAt < 10f;

		public void Play(int level, IList<string> contributors)
		{
			m_banner = $"HYPE TRAIN  -  LEVEL {level}";
			List<string> list = new List<string>(5);
			foreach (string contributor in contributors)
			{
				if (!string.IsNullOrEmpty(contributor))
				{
					list.Add(contributor.ToUpperInvariant());
					if (list.Count >= 5)
					{
						break;
					}
				}
			}
			if (list.Count == 0)
			{
				list.Add("ALL ABOARD");
			}
			m_carLabels = list.ToArray();
			m_startedAt = Time.realtimeSinceStartup;
		}

		public void Stop()
		{
			m_startedAt = float.NegativeInfinity;
		}

		public void Draw(Texture2D pixel, float scale)
		{
			float num = Time.realtimeSinceStartup - m_startedAt;
			if (!(num < 0f) && !(num >= 10f))
			{
				EnsureStyles(scale);
				m_line = Mathf.Max(1f, Mathf.Round(2f * scale));
				float[] array = MeasureCars(scale);
				float num2 = 132f * scale + Total(array) + 10f * scale * (float)array.Length;
				float num3 = (float)Screen.width + num2;
				float num4 = num / 10f;
				float num5 = (float)Screen.width - num3 * num4;
				float num6 = (float)Screen.height * 0.62f;
				float travelled = num4 * num3;
				float alpha = Mathf.Clamp01(Mathf.Min(num * 3f, (10f - num) * 1.5f));
				DrawTrack(pixel, num6, scale, alpha);
				DrawGroundShadow(pixel, num5, num2, num6, scale, alpha);
				DrawSmoke(pixel, num5 + 29.039999f * scale, num6 - 62f * scale, travelled, scale, alpha);
				float num7 = num5;
				DrawLocomotive(pixel, num7, num6, scale, travelled, alpha);
				num7 += 132f * scale;
				for (int i = 0; i < array.Length; i = checked(i + 1))
				{
					DrawCoupling(pixel, num7, num6, scale, alpha);
					num7 += 10f * scale;
					DrawCar(pixel, num7, num6, array[i], scale, travelled, m_carLabels[i], alpha);
					num7 += array[i];
				}
				DrawBanner(num5, num2, num6, scale, alpha);
			}
		}

		private float[] MeasureCars(float scale)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			float[] array = new float[m_carLabels.Length];
			for (int i = 0; i < m_carLabels.Length; i = checked(i + 1))
			{
				float x = m_carStyle.CalcSize(new GUIContent(m_carLabels[i])).x;
				array[i] = Mathf.Max(96f * scale, x + 28f * scale);
			}
			return array;
		}

		private static float Total(float[] values)
		{
			float num = 0f;
			foreach (float num2 in values)
			{
				num += num2;
			}
			return num;
		}

		private void DrawTrack(Texture2D pixel, float trackY, float scale, float alpha)
		{
			//IL_0014: 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_0038: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			Fill(pixel, new Rect(0f, trackY, (float)Screen.width, 4f * scale), TRACK, alpha);
			Fill(pixel, new Rect(0f, trackY, (float)Screen.width, m_line), Lighten(TRACK, 0.25f), alpha);
		}

		private void DrawGroundShadow(Texture2D pixel, float x, float width, float trackY, float scale, float alpha)
		{
			//IL_0029: 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)
			float num = 8f * scale;
			Fill(pixel, new Rect(x + num, trackY + 4f * scale, width - num * 2f, 5f * scale), GROUND_SHADOW, alpha);
		}

		private void DrawLocomotive(Texture2D pixel, float x, float trackY, float scale, float travelled, float alpha)
		{
			//IL_0038: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			float num = 132f * scale;
			float num2 = 62f * scale;
			float num3 = trackY - num2;
			Panel(pixel, new Rect(x + num * 0.13f, num3 + num2 * 0.02f, num * 0.2f, num2 * 0.1f), CHIMNEY, alpha);
			Panel(pixel, new Rect(x + num * 0.16f, num3 + num2 * 0.1f, num * 0.14f, num2 * 0.26f), CHIMNEY, alpha);
			Panel(pixel, new Rect(x + num * 0.62f, num3, num * 0.38f, num2), CAB, alpha);
			Panel(pixel, new Rect(x + num * 0.68f, num3 + num2 * 0.13f, num * 0.25f, num2 * 0.28f), WINDOW, alpha);
			Panel(pixel, new Rect(x, num3 + num2 * 0.34f, num * 0.66f, num2 * 0.66f), LOCO_BODY, alpha);
			Fill(pixel, new Rect(x + num * 0.42f, num3 + num2 * 0.36f, num * 0.05f, num2 * 0.6f), TRIM, alpha);
			Panel(pixel, new Rect(x + num * 0.02f, num3 + num2 * 0.44f, num * 0.1f, num2 * 0.2f), TRIM, alpha);
			Panel(pixel, new Rect(x - 7f * scale, trackY - 16f * scale, 9f * scale, 16f * scale), CAB, alpha);
			DrawWheels(pixel, x + num * 0.05f, trackY, num * 0.56f, scale, travelled, alpha, 3);
			DrawWheels(pixel, x + num * 0.7f, trackY, num * 0.24f, scale, travelled, alpha, 1);
		}

		private void DrawCar(Texture2D pixel, float x, float trackY, float width, float scale, float travelled, string label, float alpha)
		{
			//IL_0014: 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_004d: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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)
			float num = 48f * scale;
			float num2 = trackY - num;
			Panel(pixel, new Rect(x, num2, width, num), CAR_BODY, alpha);
			Fill(pixel, new Rect(x + m_line, num2 + m_line, width - m_line * 2f, 3f * scale), TRIM, alpha);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(x + 9f * scale, num2 + 11f * scale, width - 18f * scale, num - 24f * scale);
			Panel(pixel, val, NAME_PLATE, alpha);
			DrawRivets(pixel, x, num2, width, num, scale, alpha);
			GUI.color = new Color(PLATE_TEXT.r, PLATE_TEXT.g, PLATE_TEXT.b, alpha);
			GUI.Label(val, label, m_carStyle);
			DrawWheels(pixel, x + width * 0.1f, trackY, width * 0.8f, scale, travelled, alpha, 2);
		}

		private void DrawRivets(Texture2D pixel, float x, float top, float width, float height, float scale, float alpha)
		{
			//IL_001d: 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_002c: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max(m_line, 2f * scale);
			float num2 = 4f * scale;
			Color color = Darken(CAR_BODY, 0.45f);
			Fill(pixel, new Rect(x + num2, top + height * 0.3f, num, num), color, alpha);
			Fill(pixel, new Rect(x + num2, top + height * 0.62f, num, num), color, alpha);
			Fill(pixel, new Rect(x + width - num2 - num, top + height * 0.3f, num, num), color, alpha);
			Fill(pixel, new Rect(x + width - num2 - num, top + height * 0.62f, num, num), color, alpha);
		}

		private void DrawCoupling(Texture2D pixel, float x, float trackY, float scale, float alpha)
		{
			//IL_001d: 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)
			Panel(pixel, new Rect(x, trackY - 18f * scale, 10f * scale, 6f * scale), CAB, alpha);
		}

		private void DrawWheels(Texture2D pixel, float x, float trackY, float span, float scale, float travelled, float alpha, int count)
		{
			//IL_0054: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			float num = 15f * scale;
			float num2 = ((count > 1) ? ((span - num) / (float)checked(count - 1)) : 0f);
			bool flag = Mathf.FloorToInt(travelled / (num * 0.9f)) % 2 == 0;
			Rect rect = default(Rect);
			for (int i = 0; i < count; i = checked(i + 1))
			{
				float num3 = x + num2 * (float)i;
				((Rect)(ref rect))..ctor(num3, trackY - num, num, num);
				Outline(pixel, rect, alpha);
				Fill(pixel, rect, WHEEL, alpha);
				Fill(pixel, new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width, m_line), Lighten(WHEEL, 0.35f), alpha);
				Rect rect2 = (flag ? new Rect(num3 + num * 0.4f, ((Rect)(ref rect)).y + num * 0.15f, num * 0.2f, num * 0.7f) : new Rect(num3 + num * 0.15f, ((Rect)(ref rect)).y + num * 0.4f, num * 0.7f, num * 0.2f));
				Fill(pixel, rect2, WHEEL_HUB, alpha);
			}
		}

		private void DrawSmoke(Texture2D pixel, float chimneyX, float chimneyY, float travelled, float scale, float alpha)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			float num = 46f * scale;
			for (int i = 0; i < 14; i = checked(i + 1))
			{
				float num2 = travelled % num + num * (float)i;
				float num3 = num2 / (num * 14f);
				if (!(num3 >= 1f))
				{
					float num4 = (10f + num3 * 26f) * scale;
					float num5 = chimneyX + num2 - num4 * 0.5f;
					float num6 = chimneyY - num3 * 46f * scale - num4;
					float alpha2 = alpha * (1f - num3) * 0.7f;
					Fill(pixel, new Rect(num5, num6, num4, num4), SMOKE, alpha2);
					Fill(pixel, new Rect(num5, num6 + num4 * 0.62f, num4, num4 * 0.38f), Darken(SMOKE, 0.22f), alpha2);
				}
			}
		}

		private void DrawBanner(float trainX, float trainWidth, float trackY, float scale, float alpha)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0040: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = m_bannerStyle.CalcSize(new GUIContent(m_banner));
			float num = trainX + (trainWidth - val.x) * 0.5f;
			float num2 = trackY - 62f * scale - 56f * scale;
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(num, num2, val.x, val.y);
			GUI.color = new Color(OUTLINE.r, OUTLINE.g, OUTLINE.b, alpha);
			GUI.Label(new Rect(((Rect)(ref val2)).x + m_line, ((Rect)(ref val2)).y + m_line, ((Rect)(ref val2)).width, ((Rect)(ref val2)).height), m_banner, m_bannerStyle);
			GUI.color = new Color(TRIM.r, TRIM.g, TRIM.b, alpha);
			GUI.Label(val2, m_banner, m_bannerStyle);
		}

		private void Panel(Texture2D pixel, Rect rect, Color body, float alpha)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			Outline(pixel, rect, alpha);
			Rect rect2 = default(Rect);
			((Rect)(ref rect2))..ctor(((Rect)(ref rect)).x + m_line, ((Rect)(ref rect)).y + m_line, ((Rect)(ref rect)).width - m_line * 2f, ((Rect)(ref rect)).height - m_line * 2f);
			if (!(((Rect)(ref rect2)).width <= 0f) && !(((Rect)(ref rect2)).height <= 0f))
			{
				Fill(pixel, rect2, body, alpha);
				float num = Mathf.Max(m_line, ((Rect)(ref rect2)).height * 0.16f);
				Fill(pixel, new Rect(((Rect)(ref rect2)).x, ((Rect)(ref rect2)).y, ((Rect)(ref rect2)).width, num), Lighten(body, 0.32f), alpha);
				float num2 = Mathf.Max(m_line, ((Rect)(ref rect2)).height * 0.24f);
				Fill(pixel, new Rect(((Rect)(ref rect2)).x, ((Rect)(ref rect2)).yMax - num2, ((Rect)(ref rect2)).width, num2), Darken(body, 0.42f), alpha);
			}
		}

		private void Outline(Texture2D pixel, Rect rect, float alpha)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Fill(pixel, rect, OUTLINE, alpha);
		}

		private static Color Lighten(Color color, float amount)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return Color.Lerp(color, Color.white, amount);
		}

		private static Color Darken(Color color, float amount)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return Color.Lerp(color, Color.black, amount);
		}

		private static void Fill(Texture2D pixel, Rect rect, Color color, float alpha)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			GUI.color = new Color(color.r, color.g, color.b, color.a * alpha);
			GUI.DrawTexture(rect, (Texture)(object)pixel);
		}

		private void EnsureStyles(float scale)
		{
			//IL_0013: 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_001f: 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_0032: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			if (m_carStyle == null)
			{
				m_carStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)4,
					wordWrap = false,
					fontStyle = (FontStyle)1
				};
			}
			if (m_bannerStyle == null)
			{
				m_bannerStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)4,
					wordWrap = false,
					fontStyle = (FontStyle)1
				};
			}
			m_carStyle.fontSize = Mathf.RoundToInt(13f * scale);
			m_bannerStyle.fontSize = Mathf.RoundToInt(20f * scale);
			m_carStyle.normal.textColor = Color.white;
			m_bannerStyle.normal.textColor = Color.white;
		}
	}
	public class ModConfig
	{
		public enum OverlayCorner
		{
			TopLeft,
			TopRight,
			BottomLeft,
			BottomRight
		}

		private const string SECTION_DISPLAY = "Display";

		private const string SECTION_CONTROLS = "Controls";

		private const string SECTION_MULTIPLAYER = "Multiplayer";

		public ConfigEntry<bool> ShowInGameMessages { get; }

		public ConfigEntry<bool> ShowConnectionIndicator { get; }

		public ConfigEntry<bool> ShowViewerNames { get; }

		public ConfigEntry<bool> ShowHypeTrainAnimation { get; }

		public ConfigEntry<float> MessageDuration { get; }

		public ConfigEntry<OverlayCorner> OverlayPosition { get; }

		public ConfigEntry<KeyCode> ReconnectHotkey { get; }

		public ConfigEntry<KeyCode> DiagnosticsHotkey { get; }

		public ConfigEntry<bool> AllowOnlineMultiplayer { get; }

		public ModConfig(ConfigFile config)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			ShowInGameMessages = config.Bind<bool>("Display", "ShowInGameMessages", true, "Show Crowd Control messages on screen (effects starting, connection status). Turn this off for a clean capture.");
			ShowConnectionIndicator = config.Bind<bool>("Display", "ShowConnectionIndicator", true, "Show the small CROWD CONTROL connection indicator (green when connected, red when not).");
			ShowViewerNames = config.Bind<bool>("Display", "ShowViewerNames", true, "Include the name of the viewer who bought an effect in the on-screen message.");
			ShowHypeTrainAnimation = config.Bind<bool>("Display", "ShowHypeTrainAnimation", true, "Run the Hype Train across the screen, with a car for each contributor, when a Hype Train fires.");
			MessageDuration = config.Bind<float>("Display", "MessageDuration", 3f, new ConfigDescription("How long each on-screen message stays up, in seconds.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 10f), new object[0]));
			OverlayPosition = config.Bind<OverlayCorner>("Display", "OverlayPosition", OverlayCorner.TopLeft, "Which corner of the screen the Crowd Control overlay is drawn in.");
			ReconnectHotkey = config.Bind<KeyCode>("Controls", "ReconnectHotkey", (KeyCode)290, "Press this key in-game to force a Crowd Control reconnect. Set to None to disable the hotkey.");
			DiagnosticsHotkey = config.Bind<KeyCode>("Controls", "DiagnosticsHotkey", (KeyCode)289, "Press this key in-game to cycle the Crowd Control overlay: normal, then the full network diagnostics panel, then hidden. Set to None to disable the hotkey.");
			AllowOnlineMultiplayer = config.Bind<bool>("Multiplayer", "AllowOnlineMultiplayer", false, "Force EVERY effect to run during online multiplayer, including the ones known to only work on one screen (enemy spawns, explosions, freezing). Effects that are safe online already run without this. Turning it on will desync the session - it is a testing switch. Local couch co-op is always fully supported and is not affected by this setting.");
		}
	}
	public static class MultiplayerState
	{
		private sealed class Peer
		{
			public string Version = string.Empty;

			public bool HasSession;

			public float LastSeen;
		}

		public enum SessionRole
		{
			Offline,
			Host,
			Client
		}

		private const float ANNOUNCE_INTERVAL = 5f;

		private const float PEER_TIMEOUT = 15f;

		private static readonly Dictionary<int, Peer> m_peers = new Dictionary<int, Peer>();

		private static readonly float DISCOVERY_GRACE = 11f;

		private static float m_announceTimer;

		private static float m_onlineFor;

		private static bool m_wasOnline;

		private static string? m_lastLoggedStatus;

		private const int FIRST_PLAYER_PID = 5;

		public static int ModdedPeerCount => m_peers.Count;

		public static int OtherPlayerCount => RemotePlayerIds().Count;

		public static bool AllPeersReady
		{
			get
			{
				if (!CrowdControlNet.IsOnline())
				{
					return true;
				}
				int otherPlayerCount = OtherPlayerCount;
				if (otherPlayerCount == 0)
				{
					return true;
				}
				if (m_peers.Count < otherPlayerCount)
				{
					return false;
				}
				foreach (Peer value in m_peers.Values)
				{
					if (value.Version != "1.5.0.0")
					{
						return false;
					}
				}
				return true;
			}
		}

		public static SessionRole Role
		{
			get
			{
				try
				{
					if (!CrowdControlNet.IsOnline())
					{
						return SessionRole.Offline;
					}
					return Connect.IsHost ? SessionRole.Host : SessionRole.Client;
				}
				catch
				{
					return SessionRole.Offline;
				}
			}
		}

		public static string? StatusMessage
		{
			get
			{
				if (!CrowdControlNet.IsOnline())
				{
					return null;
				}
				List<int> list = MissingModPlayerIds();
				if (list.Count > 0 && m_onlineFor >= DISCOVERY_GRACE)
				{
					if (list.Count != 1)
					{
						return $"{list.Count} players are missing the Crowd Control mod";
					}
					return $"Player {list[0]} is missing the Crowd Control mod";
				}
				foreach (Peer value in m_peers.Values)
				{
					string text = DescribeVersionGap(value.Version);
					if (text != null)
					{
						return text;
					}
				}
				return null;
			}
		}

		public static string? EffectSourceDescription
		{
			get
			{
				if (!CrowdControlNet.IsOnline())
				{
					return null;
				}
				List<string> list = new List<string>();
				foreach (KeyValuePair<int, Peer> peer in m_peers)
				{
					if (peer.Value.HasSession)
					{
						list.Add(peer.Key.ToString());
					}
				}
				if (list.Count == 0)
				{
					return null;
				}
				if (list.Count != 1)
				{
					return "Players " + string.Join(", ", list.ToArray());
				}
				return "Player " + list[0];
			}
		}

		private static List<int> RemotePlayerIds()
		{
			List<int> list = new List<int>();
			try
			{
				if (!CrowdControlNet.IsOnline())
				{
					return list;
				}
				ConnectionLayer layer = Connect.Layer;
				int asInt = PID.MyID.AsInt;
				foreach (PID key in layer.PlayerIDPairs.Keys)
				{
					if (!(key == (PID)null))
					{
						int asInt2 = key.AsInt;
						if (asInt2 != asInt && asInt2 >= 5 && !layer.IsPlayerDisconnected(key))
						{
							list.Add(asInt2);
						}
					}
				}
			}
			catch
			{
			}
			return list;
		}

		private static List<int> MissingModPlayerIds()
		{
			List<int> list = new List<int>();
			foreach (int item in RemotePlayerIds())
			{
				if (!m_peers.ContainsKey(item))
				{
					list.Add(item);
				}
			}
			return list;
		}

		private static string? DescribeVersionGap(string theirs)
		{
			Version version = ParseVersion("1.5.0.0");
			Version version2 = ParseVersion(theirs);
			if (version == null)
			{
				return null;
			}
			if (version2 == null)
			{
				return "A peer reports an unreadable mod version (" + theirs + ")";
			}
			int num = version.CompareTo(version2);
			if (num == 0)
			{
				return null;
			}
			if (num >= 0)
			{
				return "A peer needs to update - they have v" + theirs;
			}
			return "Update your mod - a peer has v" + theirs;
		}

		private static Version? ParseVersion(string? value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return null;
			}
			try
			{
				return new Version(value);
			}
			catch
			{
				return null;
			}
		}

		public static void Tick()
		{
			if (!CrowdControlNet.IsOnline())
			{
				if (m_wasOnline)
				{
					Reset();
				}
				m_wasOnline = false;
				return;
			}
			if (!m_wasOnline)
			{
				m_wasOnline = true;
				m_announceTimer = 5f;
				m_onlineFor = 0f;
				CrowdControlMod.Instance.Logger.LogInfo((object)"[Crowd Control MP] Online session detected - announcing to peers.");
			}
			m_onlineFor += Time.unscaledDeltaTime;
			ExpirePeers();
			m_announceTimer += Time.unscaledDeltaTime;
			if (!(m_announceTimer < 5f))
			{
				m_announceTimer = 0f;
				CrowdControlNet.BroadcastHello();
				LogStatusIfChanged();
			}
		}

		public static void OnHello(int senderId, string version, bool hasSession)
		{
			if (senderId == PID.MyID.AsInt)
			{
				return;
			}
			if (version == null)
			{
				version = "unknown";
			}
			if (!m_peers.TryGetValue(senderId, out Peer value))
			{
				value = new Peer();
				m_peers[senderId] = value;
				string text = ((version == "1.5.0.0") ? string.Empty : "  << VERSION MISMATCH");
				string text2 = (hasSession ? "with a Crowd Control session" : "without a session");
				CrowdControlMod.Instance.Logger.LogInfo((object)$"[Crowd Control MP] Player {senderId} is running the mod v{version} {text2}.{text}");
			}
			else
			{
				if (value.Version != version)
				{
					CrowdControlMod.Instance.Logger.LogWarning((object)$"[Crowd Control MP] Player {senderId} changed version: {value.Version} -> {version}");
				}
				if (value.HasSession != hasSession)
				{
					CrowdControlMod.Instance.Logger.LogInfo((object)string.Format("[Crowd Control MP] Player {0} {1} their Crowd Control session.", senderId, hasSession ? "started" : "ended"));
				}
			}
			value.Version = version;
			value.HasSession = hasSession;
			value.LastSeen = Time.unscaledTime;
		}

		public static void Reset()
		{
			if (m_peers.Count > 0)
			{
				CrowdControlMod.Instance.Logger.LogInfo((object)"[Crowd Control MP] Session ended - clearing the peer list.");
			}
			m_peers.Clear();
			m_announceTimer = 0f;
			m_onlineFor = 0f;
			m_lastLoggedStatus = null;
		}

		private static void ExpirePeers()
		{
			float unscaledTime = Time.unscaledTime;
			List<int> list = null;
			foreach (KeyValuePair<int, Peer> peer in m_peers)
			{
				if (!(unscaledTime - peer.Value.LastSeen <= 15f))
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(peer.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (int item in list)
			{
				m_peers.Remove(item);
				CrowdControlMod.Instance.Logger.LogInfo((object)$"[Crowd Control MP] Lost contact with player {item}.");
			}
		}

		private static void LogStatusIfChanged()
		{
			string text = StatusMessage ?? string.Format("all {0} other player(s) running v{1}", OtherPlayerCount, "1.5.0.0");
			if (!(text == m_lastLoggedStatus))
			{
				m_lastLoggedStatus = text;
				CrowdControlMod.Instance.Logger.LogInfo((object)("[Crowd Control MP] " + text + "."));
				if (StatusMessage != null)
				{
					LogRoster();
				}
			}
		}

		public static void AppendDiagnostics(List<string> rows)
		{
			rows.Add($"Mode      {Role}{(CrowdControlNet.IsOnline() ? $"  (you are player {PID.MyID.AsInt})" : string.Empty)}");
			if (!CrowdControlNet.IsOnline())
			{
				return;
			}
			List<int> list = RemotePlayerIds();
			if (list.Count == 0)
			{
				rows.Add("Peers     none yet");
				return;
			}
			foreach (int item in list)
			{
				if (m_peers.TryGetValue(item, out Peer value))
				{
					rows.Add(string.Format("Player {0}  v{1}{2}{3}", item, value.Version, (value.Version == "1.5.0.0") ? string.Empty : " (MISMATCH)", value.HasSession ? ", running effects" : ", no session"));
				}
				else
				{
					rows.Add(string.Format("Player {0}  NO MOD{1}", item, (m_onlineFor < DISCOVERY_GRACE) ? " (still checking)" : string.Empty));
				}
			}
		}

		public static void LogRoster()
		{
			try
			{
				List<string> list = new List<string>();
				if (CrowdControlNet.IsOnline())
				{
					ConnectionLayer layer = Connect.Layer;
					foreach (PID key in layer.PlayerIDPairs.Keys)
					{
						if (!(key == (PID)null))
						{
							bool flag = layer.IsPlayerDisconnected(key);
							list.Add(string.Format("{0}{1}", key.AsInt, flag ? "(disconnected)" : string.Empty));
						}
					}
				}
				List<string> list2 = new List<string>();
				foreach (KeyValuePair<int, Peer> peer in m_peers)
				{
					list2.Add(string.Format("{0}=v{1}{2}", peer.Key, peer.Value.Version, peer.Value.HasSession ? "+session" : string.Empty));
				}
				CrowdControlMod.Instance.Logger.LogInfo((object)(string.Format("[Crowd Control MP] me={0}  roster=[{1}]  ", PID.MyID.AsInt, string.Join(", ", list.ToArray())) + "counted as other players=[" + string.Join(", ", RemotePlayerIds().ConvertAll((int i) => i.ToString()).ToArray()) + "]  modded peers=[" + string.Join(", ", list2.ToArray()) + "]"));
			}
			catch (Exception arg)
			{
				CrowdControlMod.Instance.Logger.LogError((object)$"[Crowd Control MP] Could not dump the roster: {arg}");
			}
		}
	}
	public class NetworkClient : IDisposable
	{
		private const bool PROCESS_LOOKUP_FALLBACK = true;

		private static readonly SITimeSpan TIMEOUT_NO_PROCESS = 5.0;

		private static readonly SITimeSpan TIMEOUT_NO_CONNECTION = 2.0;

		public static readonly string CV_HOST = "127.0.0.1";

		public static readonly int CV_PORT = 51337;

		private TcpClient? m_client;

		private DelimitedStreamReader? m_streamReader;

		private readonly CrowdControlMod m_mod;

		private volatile bool m_quitting;

		private readonly ManualResetEvent m_quitEvent = new ManualResetEvent(initialState: false);

		private readonly object m_shutdownLock = new object();

		private readonly object m_sendLock = new object();

		private readonly AutoResetEvent m_reconnectRequested = new AutoResetEvent(initialState: false);

		private volatile bool m_disposed;

		private readonly Thread m_readLoop;

		private readonly Thread m_maintenanceLoop;

		private bool m_loggedNoProcess;

		private bool m_loggedConnectFailure;

		private static readonly EmptyResponse KEEPALIVE = new EmptyResponse
		{
			type = (ResponseType)255
		};

		public bool Connected => m_client?.Connected ?? false;

		public bool HasEverConnected { get; private set; }

		public bool CrowdControlClientFound
		{
			get
			{
				if (!IsCrowdControlSemaphorePresent())
				{
					return IsCrowdControlProcessRunning();
				}
				return true;
			}
		}

		~NetworkClient()
		{
			Dispose(disposing: false);
		}

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

		protected virtual void Dispose(bool disposing)
		{
			if (!disposing)
			{
				return;
			}
			lock (m_shutdownLock)
			{
				if (m_disposed)
				{
					return;
				}
				m_disposed = true;
			}
			try
			{
				m_quitting = true;
				m_quitEvent.Set();
			}
			catch
			{
			}
			CloseConnection();
		}

		private bool WaitForReconnectOrQuit(TimeSpan timeout)
		{
			return WaitHandle.WaitAny(new WaitHandle[2] { m_quitEvent, m_reconnectRequested }, timeout) != 258;
		}

		private void CloseConnection()
		{
			lock (m_sendLock)
			{
				try
				{
					m_streamReader?.Dispose();
				}
				catch
				{
				}
				finally
				{
					m_streamReader = null;
				}
				try
				{
					TcpClient? client = m_client;
					if (client != null && client.Connected)
					{
						m_client.Client.Shutdown(SocketShutdown.Both);
					}
					m_client?.Close();
				}
				catch
				{
				}
				finally
				{
					m_client = null;
				}
			}
		}

		private static bool IsBenignShutdownException(Exception e, bool quitting)
		{
			if (!quitting && !(e is ThreadAbortException) && !(e is ObjectDisposedException) && !(e is OperationCanceledException) && (!(e is IOException { InnerException: SocketException innerException }) || !IsBenignSocketError(innerException.SocketErrorCode)))
			{
				if (e is SocketException ex2)
				{
					return IsBenignSocketError(ex2.SocketErrorCode);
				}
				return false;
			}
			return true;
		}

		private static bool IsBenignSocketError(SocketError code)
		{
			switch (code)
			{
			case SocketError.OperationAborted:
			case SocketError.Interrupted:
			case SocketError.ConnectionAborted:
			case SocketError.ConnectionReset:
			case SocketError.Shutdown:
				return true;
			default:
				return false;
			}
		}

		public bool RequestReconnect()
		{
			if (m_disposed || m_quitting)
			{
				return false;
			}
			if (!CrowdControlClientFound)
			{
				return false;
			}
			CloseConnection();
			m_loggedConnectFailure = false;
			m_reconnectRequested.Set();
			return true;
		}

		public NetworkClient(CrowdControlMod mod)
		{
			m_mod = mod;
			m_readLoop = new Thread(NetworkLoop)
			{
				IsBackground = true,
				Name = "CrowdControl.NetworkRead"
			};
			m_maintenanceLoop = new Thread(MaintenanceLoop)
			{
				IsBackground = true,
				Name = "CrowdControl.NetworkMaintenance"
			};
			m_readLoop.Start();
			m_maintenanceLoop.Start();
		}

		private void NetworkLoop()
		{
			Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
			while (!m_quitting)
			{
				if (!IsCrowdControlSemaphorePresent() && !IsCrowdControlProcessRunning())
				{
					if (!m_loggedNoProcess)
					{
						CrowdControlMod.Instance.Logger.LogInfo((object)"No Crowd Control app on this machine. The mod will sit idle unless one starts - this is normal for a player who isn't running effects.");
						m_loggedNoProcess = true;
					}
					m_loggedConnectFailure = false;
					WaitForReconnectOrQuit((TimeSpan)TIMEOUT_NO_PROCESS);
					continue;
				}
				if (m_loggedNoProcess)
				{
					CrowdControlMod.Instance.Logger.LogMessage((object)"Crowd Control client found.");
					m_loggedNoProcess = false;
				}
				if (!m_loggedConnectFailure)
				{
					CrowdControlMod.Instance.Logger.LogInfo((object)"Attempting to connect to Crowd Control");
				}
				try
				{
					m_client = new TcpClient();
					m_client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, optionValue: true);
					m_client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, optionValue: true);
					if (m_client.BeginConnect(CV_HOST, CV_PORT, null, null).AsyncWaitHandle.WaitOne(2000, exitContext: true) && m_client.Connected)
					{
						m_loggedConnectFailure = false;
						ClientLoop();
					}
					else if (!m_loggedConnectFailure)
					{
						CrowdControlMod.Instance.Logger.LogInfo((object)"Failed to connect to Crowd Control. Retrying quietly...");
						m_loggedConnectFailure = true;
					}
				}
				catch (Exception ex)
				{
					if (!IsBenignShutdownException(ex, m_quitting) && !m_loggedConnectFailure)
					{
						CrowdControlMod.Instance.Logger.LogInfo((object)("Could not reach the Crowd Control app (" + ex.GetType().Name + "). Retrying quietly..."));
						m_loggedConnectFailure = true;
					}
				}
				finally
				{
					CloseConnection();
				}
				if (!m_quitting)
				{
					WaitForReconnectOrQuit((TimeSpan)TIMEOUT_NO_CONNECTION);
					continue;
				}
				break;
			}
		}

		private void MaintenanceLoop()
		{
			Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
			while (!m_quitting)
			{
				try
				{
					if (!m_disposed)
					{
						TcpClient? client = m_client;
						if (client != null && client.Connected)
						{
							KeepAlive();
						}
					}
				}
				catch
				{
				}
				m_quitEvent.WaitOne(1000, exitContext: true);
			}
		}

		private void ClientLoop()
		{
			Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
			try
			{
				m_streamReader = new DelimitedStreamReader(m_client.GetStream());
				HasEverConnected = true;
				CrowdControlMod.Instance.Logger.LogInfo((object)"Connected to Crowd Control");
				m_mod.GameStateManager?.RequestStateResend();
				try
				{
					while (!m_quitting)
					{
						string text = m_streamReader.ReadUntilNullTerminator();
						OnMessage(text.Trim());
					}
				}
				catch (EndOfStreamException)
				{
					if (!m_quitting)
					{
						CrowdControlMod.Instance.Logger.LogInfo((object)"Disconnected from Crowd Control");
					}
				}
				catch (Exception ex2)
				{
					if (!IsBenignShutdownException(ex2, m_quitting))
					{
						CrowdControlMod.Instance.Logger.LogError((object)ex2);
						CrowdControlMod.Instance.Logger.LogError((object)"Disconnected from Crowd Control");
					}
				}
			}
			finally
			{
				CloseConnection();
			}
		}

		private void OnMessage(string message)
		{
			if (m_disposed || m_quitting || string.IsNullOrEmpty(message) || message.Trim().Length == 0)
			{
				return;
			}
			try
			{
				SimpleJSONRequest request = default(SimpleJSONRequest);
				if (SimpleJSONRequest.TryParse(message, ref request))
				{
					m_mod.Scheduler.ProcessRequest(request);
				}
			}
			catch (Exception ex)
			{
				CrowdControlMod.Instance.Logger.LogError((object)ex);
			}
		}

		private static bool IsCrowdControlSemaphorePresent()
		{
			try
			{
				Semaphore.OpenExisting("CrowdControl");
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool IsCrowdControlProcessRunning()
		{
			Process[] array = null;
			try
			{
				array = Process.GetProcesses();
				bool result = false;
				Process[] array2 = array;
				foreach (Process process in array2)
				{
					try
					{
						if (process.ProcessName.IndexOf("crowdcontrol", StringComparison.OrdinalIgnoreCase) >= 0)
						{
							return true;
						}
					}
					catch (InvalidOperationException)
					{
					}
					catch (Exception)
					{
						result = true;
					}
				}
				return result;
			}
			catch (Exception ex3)
			{
				CrowdControlMod.Instance.Logger.LogDebug((object)("Error checking for CrowdControl processes: " + ex3.Message));
				return true;
			}
			finally
			{
				if (array != null)
				{
					Process[] array2 = array;
					for (int i = 0; i < array2.Length; i++)
					{
						array2[i].Dispose();
					}
				}
			}
		}

		public bool Send(SimpleJSONResponse? response)
		{
			try
			{
				if (response == null || m_disposed || m_quitting)
				{
					return false;
				}
				byte[] bytes = Encoding.UTF8.GetBytes(((SimpleJSONMessage)response).Serialize());
				int num = 0;
				byte[] array = new byte[1 + bytes.Length];
				byte[] array2 = bytes;
				foreach (byte b in array2)
				{
					array[num] = b;
					num++;
				}
				array[num] = 0;
				byte[] array3 = array;
				lock (m_sendLock)
				{
					TcpClient? client = m_client;
					if (client == null || !client.Connected)
					{
						return false;
					}
					m_client.GetStream().Write(array3, 0, array3.Length);
					return true;
				}
			}
			catch (Exception ex)
			{
				if (!IsBenignShutdownException(ex, m_quitting))
				{
					CrowdControlMod.Instance.Logger.LogError((object)$"Error sending a message to the Crowd Control client: {ex}");
				}
				return false;
			}
		}

		public void Stop(string? message = null)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_002b: Expected O, but got Unknown
			if (!m_disposed)
			{
				if (message != null)
				{
					Send((SimpleJSONResponse?)new MessageResponse
					{
						type = (ResponseType)254,
						message = message
					});
				}
				try
				{
					m_quitting = true;
					m_quitEvent.Set();
				}
				catch
				{
				}
				CloseConnection();
			}
		}

		public bool KeepAlive()
		{
			return Send((SimpleJSONResponse?)(object)KEEPALIVE);
		}

		public void AttachMetadata(EffectResponse response)
		{
			response.metadata = new Dictionary<string, DataResponse>();
			string[] commonMetadata = MetadataDelegates.CommonMetadata;
			foreach (string text in commonMetadata)
			{
				if (MetadataLoader.Metadata.TryGetValue(text, out MetadataDelegate value))
				{
					response.metadata.Add(text, value(m_mod));
				}
				else
				{
					CrowdControlMod.Instance.Logger.LogError((object)("Metadata delegate \"" + text + "\" could not be found. Available delegates: " + string.Join(", ", MetadataLoader.Metadata.Keys.ToArray())));
				}
			}
		}

		public bool ShowEffects(params string[] codes)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return Send((SimpleJSONResponse?)new EffectUpdate(codes, (EffectStatus)128, (string)null));
		}

		public bool ShowEffects([ParamCollection] IEnumerable<string> codes)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return Send((SimpleJSONResponse?)new EffectUpdate(codes, (EffectStatus)128, (string)null));
		}

		public bool ShowAllEffects()
		{
			return ShowEffects(m_mod.EffectLoader.Effects.Keys);
		}

		public bool HideEffects(params string[] codes)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return Send((SimpleJSONResponse?)new EffectUpdate(codes, (EffectStatus)129, (string)null));
		}

		public bool HideEffects([ParamCollection] IEnumerable<string> codes)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return Send((SimpleJSONResponse?)new EffectUpdate(codes, (EffectStatus)129, (string)null));
		}

		public bool HideAllEffects()
		{
			return HideEffects(m_mod.EffectLoader.Effects.Keys);
		}

		public bool EnableEffects(params string[] codes)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return Send((SimpleJSONResponse?)new EffectUpdate(codes, (EffectStatus)130, (string)null));
		}

		public bool EnableEffects([ParamCollection] IEnumerable<string> codes)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return Send((SimpleJSONResponse?)new EffectUpdate(codes, (EffectStatus)130, (string)null));
		}

		public bool EnableAllEffects()
		{
			return EnableEffects(m_mod.EffectLoader.Effects.Keys);
		}

		public bool DisableEffects(params string[] codes)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return Send((SimpleJSONResponse?)new EffectUpdate(codes, (EffectStatus)131, (string)null));
		}

		public bool DisableEffects([ParamCollection] IEnumerable<string> codes)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return Send((SimpleJSONResponse?)new EffectUpdate(codes, (EffectStatus)131, (string)null));
		}

		public bool DisableAllEffects()
		{
			return DisableEffects(m_mod.EffectLoader.Effects.Keys);
		}
	}
	public class Overlay
	{
		private readonly struct Line
		{
			public readonly string Text;

			public readonly float Born;

			public readonly float Expires;

			public Line(string text, float born, float expires)
			{
				Text = text;
				Born = born;
				Expires = expires;
			}
		}

		public enum Status
		{
			Connected,
			Connecting,
			Disconnected,
			NoSession
		}

		public enum DisplayMode
		{
			Normal,
			Diagnostics,
			Hidden
		}

		public readonly struct ActiveEffect
		{
			public readonly string Label;

			public readonly float Remaining;

			public readonly float Duration;

			public readonly bool Paused;

			public ActiveEffect(string label, float remaining, float duration, bool paused)
			{
				Label = label;
				Remaining = remaining;
				Duration = duration;
				Paused = paused;
			}
		}

		private const float MARGIN = 14f;

		private const float WIDTH = 250f;

		private const float PAD = 8f;

		private const float ACCENT = 2f;

		private const float RADIUS = 5f;

		private const float HEADER = 16f;

		private const float ROW = 15f;

		private const float BAR = 3f;

		private const float GAP = 3f;

		private const int MAX_TEXT = 34;

		private const int MAX_LINES = 3;

		private const float REFERENCE_HEIGHT = 720f;

		private readonly ModConfig m_config;

		private readonly HypeTrainAnimation m_hypeTrain = new HypeTrainAnimation();

		private readonly List<Line> m_lines = new List<Line>();

		private readonly object m_lock = new object();

		private Texture2D? m_pixel;

		private Texture2D? m_panel;

		private int m_panelW;

		private int m_panelH;

		private GUIStyle? m_name;

		private GUIStyle? m_meta;

		private GUIStyle? m_metaRight;

		private GUIStyle? m_msg;

		private GUIStyle? m_mono;

		public Status ConnectionStatus { get; set; } = Status.Disconnected;

		public string? MultiplayerWarning { get; set; }

		public string? EffectSourceDescription { get; set; }

		public DisplayMode Mode { get; private set; }

		public bool ClientPresent { get; set; }

		public Overlay(ModConfig config)
		{
			m_config = config;
		}

		public DisplayMode CycleMode()
		{
			return Mode = Mode switch
			{
				DisplayMode.Normal => DisplayMode.Diagnostics, 
				DisplayMode.Diagnostics => DisplayMode.Hidden, 
				_ => DisplayMode.Normal, 
			};
		}

		public void ShowMessage(string? message, bool force = false)
		{
			if (string.IsNullOrEmpty(message) || (!force && !m_config.ShowInGameMessages.Value))
			{
				return;
			}
			float num = Now();
			lock (m_lock)
			{
				m_lines.Add(new Line(Trim(message), num, num + Mathf.Max(1f, m_config.MessageDuration.Value)));
				while (m_lines.Count > 3)
				{
					m_lines.RemoveAt(0);
				}
			}
		}

		public void ClearMessages()
		{
			lock (m_lock)
			{
				m_lines.Clear();
			}
		}

		public void StartHypeTrain(int level, IList<string> contributors)
		{
			if (m_config.ShowHypeTrainAnimation.Value)
			{
				m_hypeTrain.Play(level, contributors);
			}
		}

		public void StopHypeTrain()
		{
			m_hypeTrain.Stop();
		}

		public void Dispose()
		{
			Destroy(ref m_pixel);
			Destroy(ref m_panel);
		}

		private static void Destroy(ref Texture2D? texture)
		{
			if (!((Object)(object)texture == (Object)null))
			{
				try
				{
					Object.Destroy((Object)(object)texture);
				}
				catch
				{
				}
				texture = null;
			}
		}

		public void Draw()
		{
			//IL_006b: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			if (Mode == DisplayMode.Hidden)
			{
				return;
			}
			EnsureResources();
			float scale = Mathf.Max(1f, (float)Screen.height / 720f);
			int depth = GUI.depth;
			Color color = GUI.color;
			GUI.depth = -1000;
			try
			{
				if (m_hypeTrain.Active)
				{
					m_hypeTrain.Draw(m_pixel, scale);
				}
				DrawCard(scale);
			}
			finally
			{
				GUI.depth = depth;
				GUI.color = color;
			}
		}

		private void DrawCard(float scale)
		{
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Unknown result type (might be due to invalid IL or missing references)
			bool flag = Mode == DisplayMode.Diagnostics;
			if (!flag && !ClientPresent && ConnectionStatus != Status.Connected)
			{
				return;
			}
			bool value = m_config.ShowConnectionIndicator.Value;
			if (!m_config.ShowInGameMessages.Value)
			{
				ClearMessages();
			}
			ActiveEffect[] array = (value ? CrowdControlMod.Instance.Scheduler.ActiveTimedEffects() : new ActiveEffect[0]);
			Line[] array2 = TakeLines();
			string text = (value ? MultiplayerWarning : null);
			string[] array3 = (flag ? BuildDiagnostics() : new string[0]);
			bool flag2 = value || flag;
			if (!flag2 && array.Length == 0 && array2.Length == 0)
			{
				return;
			}
			ApplyScale(scale);
			float num = 8f * scale;
			float num2 = 3f * scale;
			float num3 = 15f * scale;
			float num4 = 3f * scale;
			float num5 = 16f * scale;
			float num6 = 250f * scale;
			float num7 = 2f * scale;
			float num8 = num;
			if (flag2)
			{
				num8 += num5 + num2;
			}
			if (text != null)
			{
				num8 += num3 + num2;
			}
			if (array.Length != 0)
			{
				num8 += (float)array.Length * (num3 + num4 + num2) - num2;
			}
			if (array3.Length != 0)
			{
				num8 += num2 + 1f + num2 + (float)array3.Length * num3;
			}
			if (array2.Length != 0)
			{
				if (array.Length != 0 || array3.Length != 0)
				{
					num8 += num2 + 1f + num2;
				}
				num8 += (float)array2.Length * num3;
			}
			num8 += num;
			float num9 = 14f * scale;
			ModConfig.OverlayCorner value2 = m_config.OverlayPosition.Value;
			bool flag3 = ((value2 == ModConfig.OverlayCorner.TopRight || value2 == ModConfig.OverlayCorner.BottomRight) ? true : false);
			bool flag4 = flag3;
			value2 = m_config.OverlayPosition.Value;
			flag3 = (uint)(value2 - 2) <= 1u;
			bool flag5 = flag3;
			Rect card = default(Rect);
			((Rect)(ref card))..ctor(flag4 ? ((float)Screen.width - num9 - num6) : num9, flag5 ? ((float)Screen.height - num9 - num8) : num9, num6, num8);
			DrawPanel(card, scale);
			float num10 = ((Rect)(ref card)).x + num7 + num;
			float num11 = num6 - num7 - num * 2f;
			float num12 = ((Rect)(ref card)).y + num;
			if (flag2)
			{
				DrawHeader(num10, num12, num11, num5, scale);
				num12 += num5 + num2;
			}
			if (text != null)
			{
				DrawWarning(num10, num12, num11, num3, scale, text);
				num12 += num3 + num2;
			}
			ActiveEffect[] array4 = array;
			foreach (ActiveEffect e in array4)
			{
				DrawEffect(num10, num12, num11, num3, num4, scale, e);
				num12 += num3 + num4 + num2;
			}
			if (array3.Length != 0)
			{
				num12 = DrawDivider(num10, num12, num11, num2);
				string[] array5 = array3;
				foreach (string text2 in array5)
				{
					DrawText(m_mono, new Rect(num10, num12, num11, num3), text2, CcTheme.White200);
					num12 += num3;
				}
			}
			if (array2.Length != 0)
			{
				if (array.Length != 0 || array3.Length != 0)
				{
					num12 = DrawDivider(num10, num12, num11, num2);
				}
				float num13 = Now();
				Line[] array6 = array2;
				for (int i = 0; i < array6.Length; i++)
				{
					Line line = array6[i];
					float alpha = Mathf.Min(Mathf.Clamp01((num13 - line.Born) / 0.15f), Mathf.Clamp01(line.Expires - num13));
					DrawText(m_msg, new Rect(num10, num12, num11, num3), line.Text, CcTheme.White200.Fade(alpha));
					num12 += num3;
				}
			}
		}

		private float DrawDivider(float x, float y, float w, float gap)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			Fill(new Rect(x, y + gap, w, 1f), CcTheme.Slate500);
			return y + gap + 1f + gap;
		}

		private void DrawPanel(Rect card, float scale)
		{
			//IL_0024: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			Texture2D panel = checked(GetPanel(Mathf.Max(8, (int)((Rect)(ref card)).width), Mathf.Max(8, (int)((Rect)(ref card)).height), scale));
			GUI.color = CcTheme.Slate500;
			GUI.DrawTexture(card, (Texture)(object)panel);
			GUI.color = CcTheme.Slate800.Fade(0.96f);
			GUI.DrawTexture(new Rect(((Rect)(ref card)).x + 1f, ((Rect)(ref card)).y + 1f, ((Rect)(ref card)).width - 2f, ((Rect)(ref card)).height - 2f), (Texture)(object)panel);
			GUI.color = CcTheme.Royal50;
			GUI.DrawTexture(new Rect(((Rect)(ref card)).x + 1f, ((Rect)(ref card)).y + 3f * scale, 2f * scale, ((Rect)(ref card)).height - 6f * scale), (Texture)(object)m_pixel);
		}

		private void DrawStatusDot(float x, float y, float rowH, float scale, Color status)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_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)
			float num = 8f * scale;
			Fill(new Rect(x - 2f * scale, y + (rowH - num) * 0.5f - 2f * scale, num + 4f * scale, num + 4f * scale), status.Fade(0.18f));
			Fill(new Rect(x, y + (rowH - num) * 0.5f, num, num), status);
		}

		private static float DotWidth(float scale)
		{
			return 8f * scale + 6f * scale;
		}

		private void DrawHeader(float x, float y, float w, float headerH, float scale)
		{
			//IL_0006: 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)
			//IL_0013: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			Color val = StatusColor(ConnectionStatus);
			DrawStatusDot(x, y, headerH, scale, val);
			float num = x + DotWidth(scale);
			DrawText(m_meta, new Rect(num, y, w - DotWidth(scale), headerH), "CROWD CONTROL", (ConnectionStatus == Status.Connected) ? CcTheme.White300 : val);
		}

		private void DrawWarning(float x, float y, float w, float rowH, float scale, string text)
		{
			//IL_0006: 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)
			//IL_0015: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			Fill(new Rect(x, y, w, rowH), CcTheme.Yellow300.Fade(0.14f));
			Fill(new Rect(x, y, 2f * scale, rowH), CcTheme.Yellow300);
			DrawText(m_msg, new Rect(x + 7f * scale, y, w - 9f * scale, rowH), Trim(text), CcTheme.Yellow300);
		}

		private void DrawEffect(float x, float y, float w, float rowH, float barH, float scale, ActiveEffect e)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid

BepInEx/plugins/CrowdControl/Newtonsoft.Json.dll

Decompiled a day ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Data;
using System.Data.SqlTypes;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
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.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
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: 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.4.30916")]
[assembly: AssemblyInformationalVersion("13.0.4+4e13299d4b0ec96bd4df9954ef646bd2d1b5bf2a")]
[assembly: AssemblyProduct("Json.NET")]
[assembly: AssemblyTitle("Json.NET .NET 3.5")]
[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.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, Inherited = false)]
	internal sealed class DynamicallyAccessedMembersAttribute : Attribute
	{
		public DynamicallyAccessedMemberTypes MemberTypes { get; }

		public DynamicallyAccessedMembersAttribute(DynamicallyAccessedMemberTypes memberTypes)
		{
			MemberTypes = memberTypes;
		}
	}
	[Flags]
	internal enum DynamicallyAccessedMemberTypes
	{
		None = 0,
		PublicParameterlessConstructor = 1,
		PublicConstructors = 3,
		NonPublicConstructors = 4,
		PublicMethods = 8,
		NonPublicMethods = 0x10,
		PublicFields = 0x20,
		NonPublicFields = 0x40,
		PublicNestedTypes = 0x80,
		NonPublicNestedTypes = 0x100,
		PublicProperties = 0x200,
		NonPublicProperties = 0x400,
		PublicEvents = 0x800,
		NonPublicEvents = 0x1000,
		Interfaces = 0x2000,
		All = -1
	}
	[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class FeatureGuardAttribute : Attribute
	{
		public Type FeatureType { get; }

		public FeatureGuardAttribute(Type featureType)
		{
			FeatureType = featureType;
		}
	}
	[AttributeUsage(AttributeTargets.Property, Inherited = false)]
	internal sealed class FeatureSwitchDefinitionAttribute : Attribute
	{
		public string SwitchName { get; }

		public FeatureSwitchDefinitionAttribute(string switchName)
		{
			SwitchName = switchName;
		}
	}
	[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;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	internal sealed class RequiresDynamicCodeAttribute : Attribute
	{
		public string Message { get; }

		public string? Url { get; set; }

		public RequiresDynamicCodeAttribute(string message)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	internal sealed class RequiresUnreferencedCodeAttribute : Attribute
	{
		public string Message { get; }

		public string? Url { get; set; }

		public RequiresUnreferencedCodeAttribute(string message)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
	internal sealed class UnconditionalSuppressMessageAttribute : Attribute
	{
		public string Category { get; }

		public string CheckId { get; }

		public string? Scope { get; set; }

		public string? Target { get; set; }

		public string? MessageId { get; set; }

		public string? Justification { get; set; }

		public UnconditionalSuppressMessageAttribute(string category, string checkId)
		{
			Category = category;
			CheckId = checkId;
		}
	}
}
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 = Thread.VolatileRead(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;
			Thread.VolatileWrite(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);
		}

		[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), 
				_ => throw new ArgumentException("Unsupported type: {0}. Use the JsonSerializer class to get the object's JSON representation.".FormatWith(CultureInfo.InvariantCulture, value.GetType())), 
			};
		}

		[DebuggerStepThrough]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static string SerializeObject(object? value)
		{
			return SerializeObject(value, (Type?)null, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static string SerializeObject(object? value, Formatting formatting)
		{
			return SerializeObject(value, formatting, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		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]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		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]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static string SerializeObject(object? value, JsonSerializerSettings? settings)
		{
			return SerializeObject(value, null, settings);
		}

		[DebuggerStepThrough]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static string SerializeObject(object? value, Type? type, JsonSerializerSettings? settings)
		{
			JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
			return SerializeObjectInternal(value, type, jsonSerializer);
		}

		[DebuggerStepThrough]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static string SerializeObject(object? value, Formatting formatting, JsonSerializerSettings? settings)
		{
			return SerializeObject(value, null, formatting, settings);
		}

		[DebuggerStepThrough]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		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);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		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]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static object? DeserializeObject(string value)
		{
			return DeserializeObject(value, (Type?)null, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static object? DeserializeObject(string value, JsonSerializerSettings settings)
		{
			return DeserializeObject(value, null, settings);
		}

		[DebuggerStepThrough]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static object? DeserializeObject(string value, Type type)
		{
			return DeserializeObject(value, type, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static T? DeserializeObject<T>(string value)
		{
			return JsonConvert.DeserializeObject<T>(value, (JsonSerializerSettings?)null);
		}

		[DebuggerStepThrough]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static T? DeserializeAnonymousType<T>(string value, T anonymousTypeObject)
		{
			return DeserializeObject<T>(value);
		}

		[DebuggerStepThrough]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static T? DeserializeAnonymousType<T>(string value, T anonymousTypeObject, JsonSerializerSettings settings)
		{
			return DeserializeObject<T>(value, settings);
		}

		[DebuggerStepThrough]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static T? DeserializeObject<T>(string value, params JsonConverter[] converters)
		{
			return (T)DeserializeObject(value, typeof(T), converters);
		}

		[DebuggerStepThrough]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static T? DeserializeObject<T>(string value, JsonSerializerSettings? settings)
		{
			return (T)DeserializeObject(value, typeof(T), settings);
		}

		[DebuggerStepThrough]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		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);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		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]
		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static void PopulateObject(string value, object target)
		{
			PopulateObject(value, target, null);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		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.");
				}
			}
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static string SerializeXmlNode(XmlNode? node)
		{
			return SerializeXmlNode(node, Formatting.None);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static string SerializeXmlNode(XmlNode? node, Formatting formatting)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static string SerializeXmlNode(XmlNode? node, Formatting formatting, bool omitRootObject)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
			{
				OmitRootObject = omitRootObject
			};
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static XmlDocument? DeserializeXmlNode(string value)
		{
			return DeserializeXmlNode(value, null);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName)
		{
			return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute: false);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
		{
			return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		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);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static string SerializeXNode(XObject? node)
		{
			return SerializeXNode(node, Formatting.None);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static string SerializeXNode(XObject? node, Formatting formatting)
		{
			return SerializeXNode(node, formatting, omitRootObject: false);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static string SerializeXNode(XObject? node, Formatting formatting, bool omitRootObject)
		{
			XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
			{
				OmitRootObject = omitRootObject
			};
			return SerializeObject(node, formatting, xmlNodeConverter);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static XDocument? DeserializeXNode(string value)
		{
			return DeserializeXNode(value, null);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName)
		{
			return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute: false);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
		{
			return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
		}

		[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
		[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
		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 ((object)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;
			}
		}

		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;
				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 = Convert.ToDouble(value, CultureInfo.InvariantCulture);
				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 = Convert.ToBoolean(Value, CultureInfo.InvariantCulture);
				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;
				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);
		}
	}
	[RequiresUnreferencedCode("Newtonsoft.Json relies on reflection over types that may be removed when trimming.")]
	[RequiresDynamicCode("Newtonsoft.Json relies on dynamically creating types that may not be available with Ahead of Time compilation.")]
	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.GetValueOrDefault(DateTimeZoneHandling.RoundtripKind);
			}
			set
			{
				_dateTimeZoneHandling = value;
			}
		}

		public virtual DateParseHandling DateParseHandling
		{
			get
			{
				return _dateParseHandling.GetValueOrDefault(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)
			{
				stringEscape