using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("NetKit.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.10.0")]
[assembly: AssemblyInformationalVersion("0.2.10+de8ede7c1cc4e525b56eb73ca1c0bdd9555d1cc3")]
[assembly: AssemblyProduct("NetKit.Core")]
[assembly: AssemblyTitle("NetKit.Core")]
[assembly: AssemblyMetadata("BuildStamp", "de8ede7c 2026-09-05")]
[assembly: AssemblyVersion("0.0.0.0")]
[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 NetKit.Core
{
	public struct AnnounceEntry
	{
		public string WireKey;

		public string Payload;

		public string Extra;
	}
	public sealed class AnnounceBook
	{
		private sealed class Entry
		{
			public MirrorLatch Latch;

			public string WireKey = "";

			public string LastPayload = "";

			public string LastExtra = "";
		}

		private const char KeySep = '\u001f';

		private readonly double _refreshSeconds;

		private readonly Dictionary<string, Entry> _entries = new Dictionary<string, Entry>(StringComparer.Ordinal);

		public int Count => _entries.Count;

		public AnnounceBook(double refreshSeconds)
		{
			_refreshSeconds = refreshSeconds;
		}

		public MirrorDecision Decide(string? key, string? payload, string? extra, double now)
		{
			string text = RecordKey.Canonical(key);
			if (text.Length == 0)
			{
				return MirrorDecision.None;
			}
			return EntryOf(text, key).Latch.Decide((payload == null) ? null : ComposeKey(payload, extra), now);
		}

		public void OnLanded(string? key, string payload, string? extra, double now)
		{
			string text = RecordKey.Canonical(key);
			if (text.Length != 0)
			{
				Entry entry = EntryOf(text, key);
				entry.Latch.OnSent(ComposeKey(payload, extra), now);
				entry.LastPayload = payload ?? "";
				entry.LastExtra = extra ?? "";
			}
		}

		public bool Forget(string? key)
		{
			return _entries.Remove(RecordKey.Canonical(key));
		}

		public void Invalidate(string? key)
		{
			if (_entries.TryGetValue(RecordKey.Canonical(key), out Entry value))
			{
				value.Latch.Invalidate();
			}
		}

		public void InvalidateAll()
		{
			foreach (KeyValuePair<string, Entry> entry in _entries)
			{
				entry.Value.Latch.Invalidate();
			}
		}

		public void Reset()
		{
			_entries.Clear();
		}

		public List<AnnounceEntry> FlushSnapshot()
		{
			List<AnnounceEntry> list = new List<AnnounceEntry>();
			foreach (KeyValuePair<string, Entry> entry in _entries)
			{
				if (entry.Value.Latch.HasSent)
				{
					list.Add(new AnnounceEntry
					{
						WireKey = entry.Value.WireKey,
						Payload = entry.Value.LastPayload,
						Extra = entry.Value.LastExtra
					});
				}
			}
			return list;
		}

		public bool HasLanded(string? key)
		{
			if (_entries.TryGetValue(RecordKey.Canonical(key), out Entry value))
			{
				return value.Latch.HasSent;
			}
			return false;
		}

		private Entry EntryOf(string canonical, string rawKey)
		{
			if (!_entries.TryGetValue(canonical, out Entry value))
			{
				RecordKey.TryParse(rawKey, out string ownerUid, out int slot);
				Dictionary<string, Entry> entries = _entries;
				Entry obj = new Entry
				{
					Latch = new MirrorLatch(_refreshSeconds),
					WireKey = RecordKey.Wire(ownerUid, slot)
				};
				value = obj;
				entries[canonical] = obj;
			}
			return value;
		}

		private static string ComposeKey(string payload, string? extra)
		{
			return payload + "\u001f" + extra;
		}
	}
	public static class BuildStampCompat
	{
		public const string Unknown = "unknown";

		public static bool IsKnown(string stamp)
		{
			if (!string.IsNullOrEmpty(stamp))
			{
				return !string.Equals(stamp, "unknown", StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		public static bool ShouldWarn(string ours, string theirs)
		{
			if (IsKnown(ours) && IsKnown(theirs))
			{
				return !string.Equals(ours, theirs, StringComparison.Ordinal);
			}
			return false;
		}
	}
	public static class ChannelCompat
	{
		public enum Kind
		{
			Compatible,
			ProtoMismatch,
			VersionMismatch,
			PeerMissingChannel
		}

		public static bool ProtoCompatible(int localProto, int remoteProto)
		{
			return localProto == remoteProto;
		}

		public static Kind Evaluate(int localProto, int remoteProto, string localVersion, string remoteVersion)
		{
			if (localProto != remoteProto)
			{
				return Kind.ProtoMismatch;
			}
			if (remoteVersion == null)
			{
				return Kind.PeerMissingChannel;
			}
			if (!string.Equals(localVersion, remoteVersion, StringComparison.Ordinal))
			{
				return Kind.VersionMismatch;
			}
			return Kind.Compatible;
		}

		public static bool IsReady(Kind kind)
		{
			return kind == Kind.Compatible;
		}
	}
	public static class EventFanout
	{
		public static void Raise<T>(Action<T> ev, T arg, Action<Delegate, Exception> onError)
		{
			if (ev == null)
			{
				return;
			}
			Delegate[] invocationList = ev.GetInvocationList();
			foreach (Delegate obj in invocationList)
			{
				try
				{
					((Action<T>)obj)(arg);
				}
				catch (Exception arg2)
				{
					onError?.Invoke(obj, arg2);
				}
			}
		}

		public static void ForEach<T>(IEnumerable<T> items, Action<T> body, Action<T, Exception> onError)
		{
			if (items == null || body == null)
			{
				return;
			}
			foreach (T item in items)
			{
				try
				{
					body(item);
				}
				catch (Exception arg)
				{
					onError?.Invoke(item, arg);
				}
			}
		}
	}
	public sealed class PendingOnce<T> where T : class
	{
		private readonly List<T> _items = new List<T>();

		public int Count => _items.Count;

		public bool Add(T item)
		{
			if (item == null || _items.Contains(item))
			{
				return false;
			}
			_items.Add(item);
			return true;
		}

		public List<T> Drain()
		{
			if (_items.Count == 0)
			{
				return null;
			}
			List<T> result = new List<T>(_items);
			_items.Clear();
			return result;
		}
	}
	public static class ExtensionChange
	{
		public static bool ShouldRaiseChanged(bool wasReady, bool hadPrevious, string previousExtension, string newExtension)
		{
			if (!wasReady)
			{
				return false;
			}
			if (!hadPrevious)
			{
				return false;
			}
			return !string.Equals(previousExtension ?? "", newExtension ?? "", StringComparison.Ordinal);
		}
	}
	public enum FireAndForgetAction
	{
		Skip,
		Drop,
		Apply,
		ApplyAndRelay
	}
	public readonly struct FireAndForgetDecision
	{
		public FireAndForgetAction Action { get; }

		public string? Reason { get; }

		public static FireAndForgetDecision Skip => new FireAndForgetDecision(FireAndForgetAction.Skip, null);

		public static FireAndForgetDecision Apply => new FireAndForgetDecision(FireAndForgetAction.Apply, null);

		public static FireAndForgetDecision ApplyAndRelay => new FireAndForgetDecision(FireAndForgetAction.ApplyAndRelay, null);

		private FireAndForgetDecision(FireAndForgetAction action, string? reason)
		{
			Action = action;
			Reason = reason;
		}

		public static FireAndForgetDecision Drop(string reason)
		{
			return new FireAndForgetDecision(FireAndForgetAction.Drop, reason);
		}

		public override string ToString()
		{
			if (Reason != null)
			{
				return Action.ToString() + "(" + Reason + ")";
			}
			return Action.ToString();
		}
	}
	public static class FireAndForgetLadder
	{
		public const string EmptyIdentity = "empty-identity";

		public const string DisabledOnMaster = "disabled-on-master";

		public static FireAndForgetDecision OnFire(bool enabled, bool uidEmpty, bool inRoom)
		{
			if (!enabled || uidEmpty)
			{
				return FireAndForgetDecision.Skip;
			}
			if (!inRoom)
			{
				return FireAndForgetDecision.Apply;
			}
			return FireAndForgetDecision.ApplyAndRelay;
		}

		public static FireAndForgetDecision OnCastReceived(bool enabled, bool senderIsMaster, bool senderIsSelf, bool uidEmpty, bool isLocalOwner)
		{
			return OnCastReceived(enabled, senderIsMaster, senderIsSelf, uidEmpty, isLocalOwner, masterOriginated: false);
		}

		public static FireAndForgetDecision OnCastReceived(bool enabled, bool senderIsMaster, bool senderIsSelf, bool uidEmpty, bool isLocalOwner, bool masterOriginated)
		{
			string text = RoleGuard.Evaluate(HandlerRole.SenderMustBeMaster | HandlerRole.SenderMustNotBeSelf, localIsMaster: false, senderIsMaster, senderIsSelf);
			if (text != null)
			{
				return FireAndForgetDecision.Drop(text);
			}
			if (!enabled)
			{
				return FireAndForgetDecision.Skip;
			}
			if (uidEmpty)
			{
				return FireAndForgetDecision.Drop("empty-identity");
			}
			if (isLocalOwner && !masterOriginated)
			{
				return FireAndForgetDecision.Skip;
			}
			return FireAndForgetDecision.Apply;
		}

		public static FireAndForgetDecision OnProxyReceived(bool enabled, bool localIsMaster, bool uidEmpty, string? authorizeReason)
		{
			string text = RoleGuard.Evaluate(HandlerRole.RunOnMasterOnly, localIsMaster, senderIsMaster: false, senderIsSelf: false);
			if (text != null)
			{
				return FireAndForgetDecision.Drop(text);
			}
			if (!enabled)
			{
				return FireAndForgetDecision.Drop("disabled-on-master");
			}
			if (uidEmpty)
			{
				return FireAndForgetDecision.Drop("empty-identity");
			}
			if (authorizeReason != null)
			{
				return FireAndForgetDecision.Drop(authorizeReason);
			}
			return FireAndForgetDecision.ApplyAndRelay;
		}
	}
	public static class Heartbeat
	{
		public static string Line(string tag, bool isMaster, int peers, int ready, int tx, int rx, int drops, string fragment, double photonTime)
		{
			string text = string.Format("[{0}] hb role={1} peers={2} ready={3}/{4}", tag, isMaster ? "M" : "G", peers, ready, peers) + $" pt={photonTime:F1} tx={tx} rx={rx} drops={drops}";
			if (!string.IsNullOrEmpty(fragment))
			{
				text = text + " " + fragment;
			}
			return text;
		}
	}
	public static class HelloCodec
	{
		public struct HelloMsg
		{
			public int Proto;

			public List<ChannelHello> Channels;

			public string Stamp;

			public bool SceneReady;
		}

		public struct ChannelHello
		{
			public string Channel;

			public string Version;

			public string Extension;
		}

		public const int Version = 1;

		public static string Encode(HelloMsg m)
		{
			List<ChannelHello> list = m.Channels ?? new List<ChannelHello>();
			List<string> list2 = new List<string>(2 + list.Count * 3)
			{
				NetWire.I(m.Proto),
				NetWire.I(list.Count)
			};
			foreach (ChannelHello item in list)
			{
				list2.Add(NetWire.Esc(item.Channel));
				list2.Add(NetWire.Esc(item.Version));
				list2.Add(NetWire.Esc(item.Extension));
			}
			list2.Add(NetWire.Esc(m.Stamp ?? ""));
			list2.Add(m.SceneReady ? "1" : "0");
			return NetWire.Join(list2.ToArray());
		}

		public static bool TryDecode(string payload, out HelloMsg m)
		{
			m = default(HelloMsg);
			m.Channels = new List<ChannelHello>();
			m.Stamp = "";
			List<string> list = NetWire.Split(payload);
			if (list == null || list.Count < 2)
			{
				return false;
			}
			if (!NetWire.TryI(list[0], out m.Proto) || m.Proto <= 0)
			{
				return false;
			}
			if (!NetWire.TryI(list[1], out var v) || v < 0)
			{
				return false;
			}
			if (list.Count < 2 + v * 3)
			{
				return false;
			}
			for (int i = 0; i < v; i++)
			{
				int num = 2 + i * 3;
				string text = list[num];
				if (string.IsNullOrEmpty(text))
				{
					return false;
				}
				m.Channels.Add(new ChannelHello
				{
					Channel = text,
					Version = list[num + 1],
					Extension = list[num + 2]
				});
			}
			int num2 = 2 + v * 3;
			if (list.Count > num2)
			{
				m.Stamp = list[num2];
			}
			m.SceneReady = true;
			if (list.Count > num2 + 1)
			{
				m.SceneReady = list[num2 + 1] != "0";
			}
			return true;
		}

		public static string? VersionOf(in HelloMsg m, string channel)
		{
			if (m.Channels == null)
			{
				return null;
			}
			foreach (ChannelHello channel2 in m.Channels)
			{
				if (string.Equals(channel2.Channel, channel, StringComparison.Ordinal))
				{
					return channel2.Version;
				}
			}
			return null;
		}

		public static string? ExtensionOf(in HelloMsg m, string channel)
		{
			if (m.Channels == null)
			{
				return null;
			}
			foreach (ChannelHello channel2 in m.Channels)
			{
				if (string.Equals(channel2.Channel, channel, StringComparison.Ordinal))
				{
					return channel2.Extension;
				}
			}
			return null;
		}
	}
	public sealed class HelloResend
	{
		private readonly double _intervalSeconds;

		private string? _broadcast;

		private readonly Dictionary<int, string> _targeted = new Dictionary<int, string>();

		private double _nextCheck;

		public bool HasBaseline
		{
			get
			{
				if (_broadcast == null)
				{
					return _targeted.Count > 0;
				}
				return true;
			}
		}

		public int TrackedActorCount => _targeted.Count;

		public HelloResend(double intervalSeconds)
		{
			_intervalSeconds = intervalSeconds;
		}

		public void RecordSent(string payload)
		{
			_broadcast = payload ?? "";
			_targeted.Clear();
		}

		public void RecordSentTo(int actor, string payload)
		{
			_targeted[actor] = payload ?? "";
		}

		public void ForgetActor(int actor)
		{
			_targeted.Remove(actor);
		}

		public bool DueForCheck(double now)
		{
			if (_intervalSeconds <= 0.0)
			{
				return false;
			}
			if (!HasBaseline)
			{
				return false;
			}
			if (now < _nextCheck)
			{
				return false;
			}
			_nextCheck = now + _intervalSeconds;
			return true;
		}

		public bool PayloadChanged(string currentPayload)
		{
			string b = currentPayload ?? "";
			if (_broadcast != null && !string.Equals(_broadcast, b, StringComparison.Ordinal))
			{
				return true;
			}
			foreach (KeyValuePair<int, string> item in _targeted)
			{
				if (!string.Equals(item.Value, b, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		public bool ShouldResend(double now, string currentPayload)
		{
			if (DueForCheck(now))
			{
				return PayloadChanged(currentPayload);
			}
			return false;
		}

		public void Reset()
		{
			_broadcast = null;
			_targeted.Clear();
			_nextCheck = 0.0;
		}
	}
	public enum MirrorDecision
	{
		None,
		SendChanged,
		SendPeriodic,
		Clear
	}
	public sealed class MirrorLatch
	{
		private readonly double _resendSeconds;

		private readonly bool _clearOnNull;

		private string _lastKey;

		private bool _invalidated;

		private double _resendAt;

		public bool HasSent => _lastKey != null;

		public string LastKey => _lastKey;

		public MirrorLatch(double resendSeconds = 0.0, bool clearOnNull = false)
		{
			_resendSeconds = resendSeconds;
			_clearOnNull = clearOnNull;
		}

		public MirrorDecision Decide(string key, double now)
		{
			if (key == null)
			{
				if (!_clearOnNull || !HasSent)
				{
					return MirrorDecision.None;
				}
				return MirrorDecision.Clear;
			}
			if (_invalidated || _lastKey == null || !string.Equals(key, _lastKey, StringComparison.Ordinal))
			{
				return MirrorDecision.SendChanged;
			}
			if (_resendSeconds > 0.0 && now >= _resendAt)
			{
				return MirrorDecision.SendPeriodic;
			}
			return MirrorDecision.None;
		}

		public void OnSent(string key, double now)
		{
			_lastKey = key;
			_invalidated = false;
			_resendAt = now + _resendSeconds;
		}

		public void OnCleared()
		{
			_lastKey = null;
			_invalidated = false;
		}

		public void Invalidate()
		{
			_invalidated = true;
		}

		public void Reset()
		{
			_lastKey = null;
			_invalidated = false;
		}
	}
	public sealed class NetCounters
	{
		private sealed class VerbTrace
		{
			public int Sends;

			public int Recvs;

			public int Drops;

			public double LastSendAt = -1.0;

			public double LastRecvAt = -1.0;

			public double LastDropAt = -1.0;

			public readonly Dictionary<string, int> DropReasons = new Dictionary<string, int>();
		}

		private readonly Dictionary<string, VerbTrace> _trace = new Dictionary<string, VerbTrace>();

		private readonly int _verbCap;

		private readonly int _reasonCap;

		private int _overflowEvents;

		public const int DefaultVerbCap = 64;

		public const int DefaultReasonCap = 32;

		public bool Empty
		{
			get
			{
				if (_trace.Count == 0)
				{
					return _overflowEvents == 0;
				}
				return false;
			}
		}

		public int OverflowEvents => _overflowEvents;

		public int TotalSends
		{
			get
			{
				int num = 0;
				foreach (VerbTrace value in _trace.Values)
				{
					num += value.Sends;
				}
				return num;
			}
		}

		public int TotalRecvs
		{
			get
			{
				int num = 0;
				foreach (VerbTrace value in _trace.Values)
				{
					num += value.Recvs;
				}
				return num;
			}
		}

		public int TotalDrops
		{
			get
			{
				int num = 0;
				foreach (VerbTrace value in _trace.Values)
				{
					num += value.Drops;
				}
				return num;
			}
		}

		public NetCounters()
			: this(64)
		{
		}

		public NetCounters(int verbCap, int reasonCap = 32)
		{
			_verbCap = ((verbCap < 1) ? 1 : verbCap);
			_reasonCap = ((reasonCap < 1) ? 1 : reasonCap);
		}

		private VerbTrace For(string verb)
		{
			verb = verb ?? "?";
			if (_trace.TryGetValue(verb, out VerbTrace value))
			{
				return value;
			}
			if (_trace.Count >= _verbCap)
			{
				_overflowEvents++;
				return null;
			}
			return _trace[verb] = new VerbTrace();
		}

		public void RecordSend(string verb, double now)
		{
			VerbTrace verbTrace = For(verb);
			if (verbTrace != null)
			{
				verbTrace.Sends++;
				verbTrace.LastSendAt = now;
			}
		}

		public void RecordRecv(string verb, double now)
		{
			VerbTrace verbTrace = For(verb);
			if (verbTrace != null)
			{
				verbTrace.Recvs++;
				verbTrace.LastRecvAt = now;
			}
		}

		public void RecordDrop(string verb, string reason, double now)
		{
			VerbTrace verbTrace = For(verb);
			if (verbTrace != null)
			{
				verbTrace.Drops++;
				verbTrace.LastDropAt = now;
				reason = reason ?? "?";
				if (verbTrace.DropReasons.TryGetValue(reason, out var value))
				{
					verbTrace.DropReasons[reason] = value + 1;
				}
				else if (verbTrace.DropReasons.Count >= _reasonCap)
				{
					_overflowEvents++;
				}
				else
				{
					verbTrace.DropReasons[reason] = 1;
				}
			}
		}

		public string Summary(string tag, double now)
		{
			if (_trace.Count == 0)
			{
				if (_overflowEvents != 0)
				{
					return $"[{tag}] no traffic recorded ({_overflowEvents} event(s) refused by the counter caps).";
				}
				return "[" + tag + "] no traffic recorded.";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append($"[{tag}] traffic (t={now:F0}s):");
			List<string> list = new List<string>(_trace.Keys);
			list.Sort(StringComparer.Ordinal);
			foreach (string item in list)
			{
				VerbTrace verbTrace = _trace[item];
				string arg = "";
				if (verbTrace.Drops > 0)
				{
					List<string> list2 = new List<string>();
					foreach (KeyValuePair<string, int> dropReason in verbTrace.DropReasons)
					{
						list2.Add($"{dropReason.Key}×{dropReason.Value}");
					}
					list2.Sort(StringComparer.Ordinal);
					arg = string.Format(" drop={0} ({1}) lastDrop={2:F0}s", verbTrace.Drops, string.Join(", ", list2.ToArray()), verbTrace.LastDropAt);
				}
				stringBuilder.Append(string.Format("\n[{0}]   {1}: send={2}{3}", tag, item, verbTrace.Sends, (verbTrace.Sends > 0) ? $" lastSend={verbTrace.LastSendAt:F0}s" : "") + string.Format(" recv={0}{1}{2}", verbTrace.Recvs, (verbTrace.Recvs > 0) ? $" lastRecv={verbTrace.LastRecvAt:F0}s" : "", arg));
			}
			if (_overflowEvents > 0)
			{
				stringBuilder.Append($"\n[{tag}]   (+{_overflowEvents} event(s) refused by the counter caps: " + $"verbCap={_verbCap} reasonCap={_reasonCap} — a channel legitimately has a handful " + "of constant verbs, so hitting this means something is inventing them.)");
			}
			return stringBuilder.ToString();
		}
	}
	internal static class NetWire
	{
		public static string I(int v)
		{
			return v.ToString(CultureInfo.InvariantCulture);
		}

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

		public static bool TryI(string s, out int v)
		{
			return int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out v);
		}

		public static bool TryF(string s, out float v)
		{
			return float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out v);
		}

		public static string Join(params string[] fields)
		{
			return string.Join(";", fields);
		}

		public static string Esc(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder(s.Length + 4);
			foreach (char c in s)
			{
				switch (c)
				{
				case '\\':
					stringBuilder.Append("\\\\");
					break;
				case ';':
					stringBuilder.Append("\\s");
					break;
				case '\n':
					stringBuilder.Append("\\n");
					break;
				default:
					stringBuilder.Append(c);
					break;
				}
			}
			return stringBuilder.ToString();
		}

		public static List<string>? Split(string payload)
		{
			if (payload == null)
			{
				return null;
			}
			List<string> list = new List<string>();
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < payload.Length; i++)
			{
				char c = payload[i];
				switch (c)
				{
				case '\\':
					if (i + 1 >= payload.Length)
					{
						return null;
					}
					switch (payload[++i])
					{
					case '\\':
						stringBuilder.Append('\\');
						break;
					case 's':
						stringBuilder.Append(';');
						break;
					case 'n':
						stringBuilder.Append('\n');
						break;
					default:
						return null;
					}
					break;
				case ';':
					list.Add(stringBuilder.ToString());
					stringBuilder.Length = 0;
					break;
				default:
					stringBuilder.Append(c);
					break;
				}
			}
			list.Add(stringBuilder.ToString());
			return list;
		}
	}
	public sealed class NoHandlerDrops
	{
		public readonly struct Entry
		{
			public string Channel { get; }

			public string Verb { get; }

			public int Count { get; }

			public Entry(string channel, string verb, int count)
			{
				Channel = channel;
				Verb = verb;
				Count = count;
			}
		}

		private readonly Dictionary<string, Dictionary<string, int>> _byChannel = new Dictionary<string, Dictionary<string, int>>(StringComparer.Ordinal);

		public bool Empty
		{
			get
			{
				foreach (Dictionary<string, int> value in _byChannel.Values)
				{
					if (value.Count > 0)
					{
						return false;
					}
				}
				return true;
			}
		}

		public bool Record(string channel, string verb)
		{
			channel = channel ?? "?";
			verb = verb ?? "?";
			if (!_byChannel.TryGetValue(channel, out Dictionary<string, int> value))
			{
				value = (_byChannel[channel] = new Dictionary<string, int>(StringComparer.Ordinal));
			}
			bool result = !value.ContainsKey(verb);
			value.TryGetValue(verb, out var value2);
			value[verb] = value2 + 1;
			return result;
		}

		public int Count(string channel, string verb)
		{
			if (channel != null && verb != null && _byChannel.TryGetValue(channel, out Dictionary<string, int> value) && value.TryGetValue(verb, out var value2))
			{
				return value2;
			}
			return 0;
		}

		public IEnumerable<Entry> NonZero()
		{
			List<string> list = new List<string>(_byChannel.Keys);
			list.Sort(StringComparer.Ordinal);
			foreach (string c in list)
			{
				List<string> list2 = new List<string>(_byChannel[c].Keys);
				list2.Sort(StringComparer.Ordinal);
				foreach (string item in list2)
				{
					yield return new Entry(c, item, _byChannel[c][item]);
				}
			}
		}

		public string Summary(string tag)
		{
			List<string> list = new List<string>();
			foreach (Entry item in NonZero())
			{
				list.Add($"{item.Channel}.{item.Verb}×{item.Count}");
			}
			if (list.Count != 0)
			{
				return "[" + tag + "] droppedVerbs: " + string.Join(", ", list.ToArray());
			}
			return "[" + tag + "] droppedVerbs: none";
		}
	}
	public static class PayloadSizeGuard
	{
		public const int PunPracticalLimitBytes = 32717;

		public const int WarnThresholdBytes = 26173;

		public static int Utf8ByteSize(string payload)
		{
			if (!string.IsNullOrEmpty(payload))
			{
				return Encoding.UTF8.GetByteCount(payload);
			}
			return 0;
		}

		public static bool ShouldWarn(int utf8ByteSize)
		{
			return utf8ByteSize >= 26173;
		}
	}
	public sealed class PayloadSizeWarnLedger
	{
		private readonly HashSet<string> _warned = new HashSet<string>(StringComparer.Ordinal);

		public static string Key(string channelId, string verb)
		{
			return channelId + "|" + verb;
		}

		public bool ShouldWarn(string channelId, string verb)
		{
			return _warned.Add(Key(channelId, verb));
		}

		public void Clear()
		{
			_warned.Clear();
		}
	}
	public sealed class PeerHelloStore
	{
		public struct Entry
		{
			public int Actor;

			public HelloCodec.HelloMsg Hello;

			public bool IsMaster;
		}

		public struct ChannelReadiness
		{
			public int Actor;

			public bool Ready;

			public ChannelCompat.Kind Kind;

			public string Version;

			public string Extension;

			public bool IsMaster;
		}

		private readonly Dictionary<int, Entry> _entries = new Dictionary<int, Entry>();

		public int Count => _entries.Count;

		public IEnumerable<Entry> Entries => _entries.Values;

		public void Record(int actor, HelloCodec.HelloMsg hello, bool isMaster)
		{
			_entries[actor] = new Entry
			{
				Actor = actor,
				Hello = hello,
				IsMaster = isMaster
			};
		}

		public bool TryGet(int actor, out Entry entry)
		{
			return _entries.TryGetValue(actor, out entry);
		}

		public void Remove(int actor)
		{
			_entries.Remove(actor);
		}

		public void Clear()
		{
			_entries.Clear();
		}

		public List<ChannelReadiness> EvaluateChannel(int localProto, string channelId, string localVersion)
		{
			List<ChannelReadiness> list = new List<ChannelReadiness>(_entries.Count);
			foreach (Entry value in _entries.Values)
			{
				Entry current = value;
				string text = HelloCodec.VersionOf(in current.Hello, channelId);
				ChannelCompat.Kind kind = ChannelCompat.Evaluate(localProto, current.Hello.Proto, localVersion, text);
				list.Add(new ChannelReadiness
				{
					Actor = current.Actor,
					Ready = ChannelCompat.IsReady(kind),
					Kind = kind,
					Version = (text ?? ""),
					Extension = (HelloCodec.ExtensionOf(in current.Hello, channelId) ?? ""),
					IsMaster = current.IsMaster
				});
			}
			return list;
		}
	}
	public sealed class PeerLedger
	{
		private readonly Dictionary<int, double> _expectedSince = new Dictionary<int, double>();

		private readonly HashSet<int> _helloed = new HashSet<int>();

		public int PendingCount => _expectedSince.Count;

		public int HelloedCount => _helloed.Count;

		public IReadOnlyDictionary<int, double> Pending => _expectedSince;

		public bool HasHello(int actor)
		{
			return _helloed.Contains(actor);
		}

		public bool Expect(int actor, double now)
		{
			if (_helloed.Contains(actor))
			{
				return false;
			}
			if (_expectedSince.ContainsKey(actor))
			{
				return false;
			}
			_expectedSince[actor] = now;
			return true;
		}

		public void MarkHello(int actor)
		{
			_expectedSince.Remove(actor);
			_helloed.Add(actor);
		}

		public List<int>? DueForWarning(double now, double warnSeconds)
		{
			List<int> list = null;
			if (_expectedSince.Count == 0)
			{
				return null;
			}
			foreach (KeyValuePair<int, double> item in _expectedSince)
			{
				if (now - item.Value > warnSeconds)
				{
					(list ?? (list = new List<int>())).Add(item.Key);
				}
			}
			if (list != null)
			{
				foreach (int item2 in list)
				{
					_expectedSince.Remove(item2);
				}
			}
			return list;
		}

		public double GraceElapsed(int actor, double now)
		{
			if (!_expectedSince.TryGetValue(actor, out var value))
			{
				return -1.0;
			}
			return now - value;
		}

		public void Reset()
		{
			_expectedSince.Clear();
			_helloed.Clear();
		}
	}
	public static class PunLog
	{
		public static readonly string[] Signatures = new string[3] { "Received OnSerialization for view ID", "has no method", "PhotonView ID duplicate found" };

		public static int Match(string condition)
		{
			if (string.IsNullOrEmpty(condition))
			{
				return -1;
			}
			for (int i = 0; i < Signatures.Length; i++)
			{
				if (condition.IndexOf(Signatures[i], StringComparison.Ordinal) >= 0)
				{
					return i;
				}
			}
			return -1;
		}

		public static bool TryParseViewId(string condition, out int id)
		{
			id = 0;
			if (string.IsNullOrEmpty(condition))
			{
				return false;
			}
			int num = condition.IndexOf(Signatures[0], StringComparison.Ordinal);
			if (num < 0)
			{
				return false;
			}
			int i;
			for (i = num + Signatures[0].Length; i < condition.Length && !char.IsDigit(condition[i]); i++)
			{
			}
			int j;
			for (j = i; j < condition.Length && char.IsDigit(condition[j]); j++)
			{
			}
			if (j <= i)
			{
				return false;
			}
			return int.TryParse(condition.Substring(i, j - i), out id);
		}
	}
	public sealed class PunSignatureCounters
	{
		private readonly int[] _counts = new int[PunLog.Signatures.Length];

		private readonly double[] _firstAt;

		private readonly double[] _lastAt;

		public int UnknownViewCount => _counts[0];

		public PunSignatureCounters()
		{
			_firstAt = new double[PunLog.Signatures.Length];
			_lastAt = new double[PunLog.Signatures.Length];
			for (int i = 0; i < _firstAt.Length; i++)
			{
				_firstAt[i] = -1.0;
				_lastAt[i] = -1.0;
			}
		}

		public void Record(int signatureIndex, double now)
		{
			if (signatureIndex >= 0 && signatureIndex < _counts.Length)
			{
				_counts[signatureIndex]++;
				if (_firstAt[signatureIndex] < 0.0)
				{
					_firstAt[signatureIndex] = now;
				}
				_lastAt[signatureIndex] = now;
			}
		}

		public int Count(int signatureIndex)
		{
			if (signatureIndex < 0 || signatureIndex >= _counts.Length)
			{
				return 0;
			}
			return _counts[signatureIndex];
		}

		public string Summary(string tag)
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < PunLog.Signatures.Length; i++)
			{
				if (_counts[i] > 0)
				{
					stringBuilder.Append($"\n[{tag}] PUN-signature '{PunLog.Signatures[i]}': {_counts[i]}× " + $"(first {_firstAt[i]:F0}s, last {_lastAt[i]:F0}s)");
				}
			}
			if (stringBuilder.Length != 0)
			{
				return stringBuilder.ToString(1, stringBuilder.Length - 1);
			}
			return "";
		}
	}
	public sealed class UnknownViewTable
	{
		private sealed class Row
		{
			public int Count;

			public double FirstAt;

			public double LastAt;

			public bool RunawayAnnounced;
		}

		private readonly Dictionary<int, Row> _rows = new Dictionary<int, Row>();

		private readonly int _cap;

		private readonly int _runawayThreshold;

		public const int DefaultRunawayThreshold = 500;

		public int IdCount => _rows.Count;

		public UnknownViewTable(int cap = 64, int runawayThreshold = 500)
		{
			_cap = ((cap < 1) ? 1 : cap);
			_runawayThreshold = ((runawayThreshold < 1) ? 1 : runawayThreshold);
		}

		public bool Record(int id, double now)
		{
			bool runaway;
			return Record(id, now, out runaway);
		}

		public bool Record(int id, double now, out bool runaway)
		{
			runaway = false;
			if (_rows.TryGetValue(id, out Row value))
			{
				value.Count++;
				value.LastAt = now;
				if (!value.RunawayAnnounced && value.Count >= _runawayThreshold)
				{
					value.RunawayAnnounced = true;
					runaway = true;
				}
				return false;
			}
			if (_rows.Count >= _cap)
			{
				return false;
			}
			_rows[id] = new Row
			{
				Count = 1,
				FirstAt = now,
				LastAt = now
			};
			return true;
		}

		public int CountOf(int id)
		{
			if (!_rows.TryGetValue(id, out Row value))
			{
				return 0;
			}
			return value.Count;
		}

		public string TopSummary(int max = 4)
		{
			if (_rows.Count == 0 || max < 1)
			{
				return "";
			}
			List<KeyValuePair<int, Row>> list = new List<KeyValuePair<int, Row>>(_rows);
			list.Sort((KeyValuePair<int, Row> a, KeyValuePair<int, Row> b) => b.Value.Count.CompareTo(a.Value.Count));
			StringBuilder stringBuilder = new StringBuilder();
			int num = ((list.Count < max) ? list.Count : max);
			for (int num2 = 0; num2 < num; num2++)
			{
				if (num2 > 0)
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append(list[num2].Key).Append('×').Append(list[num2].Value.Count);
			}
			return stringBuilder.ToString();
		}

		public string Format(string tag)
		{
			if (_rows.Count == 0)
			{
				return "[" + tag + "] unknown-view table: empty.";
			}
			StringBuilder stringBuilder = new StringBuilder($"[{tag}] unknown-view table ({_rows.Count} id(s)):");
			foreach (KeyValuePair<int, Row> row in _rows)
			{
				stringBuilder.Append($"\n[{tag}]   id={row.Key}: {row.Value.Count}× (first {row.Value.FirstAt:F0}s, last {row.Value.LastAt:F0}s)");
			}
			return stringBuilder.ToString();
		}
	}
	public sealed class QuietVerbSet
	{
		public static readonly QuietVerbSet Empty = new QuietVerbSet(null);

		private readonly HashSet<string> _verbs;

		public int Count
		{
			get
			{
				if (_verbs == null)
				{
					return 0;
				}
				return _verbs.Count;
			}
		}

		public QuietVerbSet(IEnumerable<string> verbs)
		{
			if (verbs == null)
			{
				return;
			}
			foreach (string verb in verbs)
			{
				if (!string.IsNullOrEmpty(verb))
				{
					(_verbs ?? (_verbs = new HashSet<string>(StringComparer.Ordinal))).Add(verb);
				}
			}
		}

		public bool IsQuiet(string verb)
		{
			if (_verbs != null && verb != null)
			{
				return _verbs.Contains(verb);
			}
			return false;
		}
	}
	public static class RecordKey
	{
		public const char Separator = ':';

		private const char ExtraSep = '\u001f';

		public static bool TryParse(string? wireKey, out string ownerUid, out int slot)
		{
			ownerUid = wireKey ?? "";
			slot = 0;
			if (string.IsNullOrEmpty(wireKey))
			{
				return false;
			}
			int num = wireKey.LastIndexOf(':');
			if (num > 0 && num < wireKey.Length - 1 && int.TryParse(wireKey.Substring(num + 1), NumberStyles.None, CultureInfo.InvariantCulture, out var result))
			{
				ownerUid = wireKey.Substring(0, num);
				slot = result;
			}
			return ownerUid.Length > 0;
		}

		public static string Canonical(string? wireKey)
		{
			if (!TryParse(wireKey, out string ownerUid, out int slot))
			{
				return "";
			}
			return Compose(ownerUid, slot);
		}

		public static string Compose(string ownerUid, int slot)
		{
			return ownerUid + ":" + ((slot >= 0) ? slot : 0).ToString(CultureInfo.InvariantCulture);
		}

		public static string Wire(string ownerUid, int slot)
		{
			if (slot > 0)
			{
				return ownerUid + ":" + slot.ToString(CultureInfo.InvariantCulture);
			}
			return ownerUid;
		}

		public static string EncodeExtraSlot(string wireKey, string? extra)
		{
			if (!string.IsNullOrEmpty(extra))
			{
				return wireKey + "\u001f" + extra;
			}
			return wireKey;
		}

		public static void DecodeExtraSlot(string? slotValue, out string wireKey, out string extra)
		{
			string text = slotValue ?? "";
			int num = text.IndexOf('\u001f');
			if (num < 0)
			{
				wireKey = text;
				extra = "";
			}
			else
			{
				wireKey = text.Substring(0, num);
				extra = text.Substring(num + 1);
			}
		}
	}
	public enum OwnerResolution
	{
		Unknown,
		OwnedBySender,
		NotOwnedBySender
	}
	public enum RebindRule
	{
		OnlyIfPrevActorGone
	}
	public enum RecordApply
	{
		RefusedEmptyKey,
		DeferredOwnerUnknown,
		RefusedNotOwner,
		RefusedRebindLive,
		Created,
		Updated,
		Refreshed,
		Rebound
	}
	public static class StoreReleaseWire
	{
		public const string OwnerReleasePrefix = "owner release: ";

		public const string DefaultReason = "released by owner";
	}
	public enum RecordRelease
	{
		NoRow,
		RefusedWrongSender,
		Cleared
	}
	public enum RecordTickStep
	{
		Keep,
		ClearOwnerMissing
	}
	public sealed class RecordRow
	{
		public string Key { get; internal set; } = "";

		public string OwnerUid { get; internal set; } = "";

		public int Slot { get; internal set; }

		public int ActorId { get; internal set; }

		public string Payload { get; internal set; } = "";

		public string Extra { get; internal set; } = "";

		public double LastSetAt { get; internal set; }

		public double OwnerMissingSince { get; internal set; }
	}
	public sealed class RecordTable
	{
		private readonly Dictionary<string, RecordRow> _rows = new Dictionary<string, RecordRow>(StringComparer.Ordinal);

		public int Count => _rows.Count;

		public bool TryGet(string? wireKey, out RecordRow row)
		{
			return _rows.TryGetValue(RecordKey.Canonical(wireKey), out row);
		}

		public List<RecordRow> RowsSnapshot()
		{
			List<RecordRow> list = new List<RecordRow>(_rows.Count);
			foreach (KeyValuePair<string, RecordRow> row in _rows)
			{
				list.Add(row.Value);
			}
			return list;
		}

		public RecordApply Apply(string? wireKey, string? payload, string? extra, int senderActor, double now, Func<int, bool>? actorPresent, Func<string, int, int, OwnerResolution>? resolveOwner, out RecordRow? row)
		{
			row = null;
			if (!RecordKey.TryParse(wireKey, out string ownerUid, out int slot))
			{
				return RecordApply.RefusedEmptyKey;
			}
			string key = RecordKey.Compose(ownerUid, slot);
			payload = payload ?? "";
			extra = extra ?? "";
			if (!_rows.TryGetValue(key, out RecordRow value))
			{
				switch (Resolve(resolveOwner, ownerUid, slot, senderActor))
				{
				case OwnerResolution.Unknown:
					return RecordApply.DeferredOwnerUnknown;
				case OwnerResolution.NotOwnedBySender:
					return RecordApply.RefusedNotOwner;
				default:
					row = new RecordRow
					{
						Key = key,
						OwnerUid = ownerUid,
						Slot = slot,
						ActorId = senderActor
					};
					Stamp(row, payload, extra, now);
					_rows[key] = row;
					return RecordApply.Created;
				}
			}
			if (value.ActorId != senderActor)
			{
				if (actorPresent == null || actorPresent(value.ActorId))
				{
					return RecordApply.RefusedRebindLive;
				}
				switch (Resolve(resolveOwner, ownerUid, slot, senderActor))
				{
				case OwnerResolution.Unknown:
					return RecordApply.DeferredOwnerUnknown;
				case OwnerResolution.NotOwnedBySender:
					return RecordApply.RefusedNotOwner;
				default:
					value.ActorId = senderActor;
					value.OwnerMissingSince = 0.0;
					Stamp(value, payload, extra, now);
					row = value;
					return RecordApply.Rebound;
				}
			}
			bool num = !string.Equals(value.Payload, payload, StringComparison.Ordinal) || !string.Equals(value.Extra, extra, StringComparison.Ordinal);
			Stamp(value, payload, extra, now);
			row = value;
			if (!num)
			{
				return RecordApply.Refreshed;
			}
			return RecordApply.Updated;
		}

		private static OwnerResolution Resolve(Func<string, int, int, OwnerResolution>? resolveOwner, string uid, int slot, int senderActor)
		{
			return resolveOwner?.Invoke(uid, slot, senderActor) ?? OwnerResolution.OwnedBySender;
		}

		private static void Stamp(RecordRow row, string payload, string extra, double now)
		{
			row.Payload = payload;
			row.Extra = extra;
			row.LastSetAt = now;
		}

		public RecordRelease Release(string? wireKey, int senderActor, out RecordRow? row)
		{
			row = null;
			string key = RecordKey.Canonical(wireKey);
			if (!_rows.TryGetValue(key, out RecordRow value))
			{
				return RecordRelease.NoRow;
			}
			if (value.ActorId != senderActor)
			{
				return RecordRelease.RefusedWrongSender;
			}
			_rows.Remove(key);
			row = value;
			return RecordRelease.Cleared;
		}

		public bool Clear(string? wireKey, out RecordRow? row)
		{
			string key = RecordKey.Canonical(wireKey);
			if (!_rows.TryGetValue(key, out RecordRow value))
			{
				row = null;
				return false;
			}
			_rows.Remove(key);
			row = value;
			return true;
		}

		public List<RecordRow> ClearActor(int actorId)
		{
			List<RecordRow> list = new List<RecordRow>();
			foreach (KeyValuePair<string, RecordRow> row in _rows)
			{
				if (row.Value.ActorId == actorId)
				{
					list.Add(row.Value);
				}
			}
			foreach (RecordRow item in list)
			{
				_rows.Remove(item.Key);
			}
			return list;
		}

		public List<RecordRow> ClearAll()
		{
			List<RecordRow> result = RowsSnapshot();
			_rows.Clear();
			return result;
		}

		public RecordTickStep TickRow(RecordRow row, bool ownerResolvable, double now, double ownerMissingSeconds)
		{
			if (row == null)
			{
				return RecordTickStep.Keep;
			}
			if (ownerResolvable)
			{
				row.OwnerMissingSince = 0.0;
				return RecordTickStep.Keep;
			}
			if (row.OwnerMissingSince <= 0.0)
			{
				row.OwnerMissingSince = now;
				return RecordTickStep.Keep;
			}
			if (!(now - row.OwnerMissingSince > ownerMissingSeconds))
			{
				return RecordTickStep.Keep;
			}
			return RecordTickStep.ClearOwnerMissing;
		}
	}
	public sealed class RequestBook
	{
		public struct Expired
		{
			public string Verb;

			public string Token;
		}

		private sealed class Row
		{
			public string Verb;

			public double Deadline;
		}

		public const string RefusedInFlight = "in-flight";

		private readonly Dictionary<string, Row> _byToken = new Dictionary<string, Row>(StringComparer.Ordinal);

		private int _counter;

		public int PendingCount => _byToken.Count;

		public string Begin(string verb, int actor, double now, double timeoutSeconds, bool singleFlight, out string refusal)
		{
			refusal = null;
			if (singleFlight && HasPending(verb))
			{
				refusal = "in-flight";
				return null;
			}
			string text = actor.ToString(CultureInfo.InvariantCulture) + "-" + (++_counter).ToString(CultureInfo.InvariantCulture);
			_byToken[text] = new Row
			{
				Verb = verb,
				Deadline = now + timeoutSeconds
			};
			return text;
		}

		public void Abort(string token)
		{
			if (token != null)
			{
				_byToken.Remove(token);
			}
		}

		public bool TryResolve(string token, out string verb)
		{
			verb = null;
			if (token == null || !_byToken.TryGetValue(token, out Row value))
			{
				return false;
			}
			verb = value.Verb;
			_byToken.Remove(token);
			return true;
		}

		public List<Expired> TakeExpired(double now)
		{
			List<Expired> list = null;
			List<string> list2 = null;
			foreach (KeyValuePair<string, Row> item in _byToken)
			{
				if (!(item.Value.Deadline > now))
				{
					(list ?? (list = new List<Expired>())).Add(new Expired
					{
						Verb = item.Value.Verb,
						Token = item.Key
					});
					(list2 ?? (list2 = new List<string>())).Add(item.Key);
				}
			}
			if (list2 != null)
			{
				foreach (string item2 in list2)
				{
					_byToken.Remove(item2);
				}
			}
			return list;
		}

		public List<Expired> TakeAll()
		{
			if (_byToken.Count == 0)
			{
				return null;
			}
			List<Expired> list = new List<Expired>(_byToken.Count);
			foreach (KeyValuePair<string, Row> item in _byToken)
			{
				list.Add(new Expired
				{
					Verb = item.Value.Verb,
					Token = item.Key
				});
			}
			_byToken.Clear();
			return list;
		}

		public bool HasPending(string verb)
		{
			foreach (KeyValuePair<string, Row> item in _byToken)
			{
				if (string.Equals(item.Value.Verb, verb, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		public bool TryGetPending(string verb, out string token, out double deadline)
		{
			foreach (KeyValuePair<string, Row> item in _byToken)
			{
				if (string.Equals(item.Value.Verb, verb, StringComparison.Ordinal))
				{
					token = item.Key;
					deadline = item.Value.Deadline;
					return true;
				}
			}
			token = null;
			deadline = 0.0;
			return false;
		}
	}
	public static class RequestCodec
	{
		public static string Sanitize(string s)
		{
			if (!string.IsNullOrEmpty(s))
			{
				return s.Replace('\t', ' ');
			}
			return "";
		}

		public static string EncodeRequest(string token, string payload)
		{
			if (!string.IsNullOrEmpty(payload))
			{
				return Sanitize(token) + "\t" + payload;
			}
			return Sanitize(token);
		}

		public static bool TryParseRequest(string wire, out string token, out string payload)
		{
			token = "";
			payload = "";
			if (string.IsNullOrEmpty(wire))
			{
				return false;
			}
			int num = wire.IndexOf('\t');
			if (num < 0)
			{
				token = wire;
				return true;
			}
			if (num == 0)
			{
				return false;
			}
			token = wire.Substring(0, num);
			payload = wire.Substring(num + 1);
			return true;
		}

		public static string EncodeAck(string token, string result)
		{
			return Sanitize(token) + "\t" + Sanitize(result);
		}

		public static bool TryParseAck(string wire, out string token, out string result)
		{
			token = "";
			result = "";
			if (string.IsNullOrEmpty(wire))
			{
				return false;
			}
			int num = wire.IndexOf('\t');
			if (num <= 0 || num == wire.Length - 1)
			{
				return false;
			}
			string text = wire.Substring(num + 1);
			if (text.IndexOf('\t') >= 0)
			{
				return false;
			}
			token = wire.Substring(0, num);
			result = text;
			return true;
		}
	}
	[Flags]
	public enum HandlerRole
	{
		Any = 0,
		RunOnMasterOnly = 1,
		RunOnGuestOnly = 2,
		SenderMustBeMaster = 4,
		SenderMustNotBeSelf = 8
	}
	public static class RoleGuard
	{
		public const string NotMasterMachine = "role:not-master-machine";

		public const string NotGuestMachine = "role:not-guest-machine";

		public const string SenderNotMaster = "role:sender-not-master";

		public const string SenderIsSelf = "role:sender-is-self";

		public static string? Evaluate(HandlerRole role, bool localIsMaster, bool senderIsMaster, bool senderIsSelf)
		{
			if ((role & HandlerRole.RunOnMasterOnly) != HandlerRole.Any && !localIsMaster)
			{
				return "role:not-master-machine";
			}
			if ((role & HandlerRole.RunOnGuestOnly) != 0 && localIsMaster)
			{
				return "role:not-guest-machine";
			}
			if ((role & HandlerRole.SenderMustBeMaster) != HandlerRole.Any && !senderIsMaster)
			{
				return "role:sender-not-master";
			}
			if ((role & HandlerRole.SenderMustNotBeSelf) != 0 && senderIsSelf)
			{
				return "role:sender-is-self";
			}
			return null;
		}
	}
	public struct RoomChange
	{
		public string? OldRoomName;

		public string? NewRoomName;
	}
	public sealed class RoomWatch
	{
		private bool _inRoom;

		private string? _room;

		public bool Update(bool inRoom, string? roomName, out RoomChange change)
		{
			string text = (inRoom ? (roomName ?? "") : null);
			string text2 = (_inRoom ? (_room ?? "") : null);
			if (string.Equals(text, text2, StringComparison.Ordinal))
			{
				change = default(RoomChange);
				return false;
			}
			change = new RoomChange
			{
				OldRoomName = text2,
				NewRoomName = text
			};
			_inRoom = inRoom;
			_room = roomName;
			return true;
		}
	}
	public sealed class SceneReadyGate
	{
		private string? _firedScene;

		public bool Fire(bool inRoom, bool ready, string? scene)
		{
			if (!inRoom)
			{
				_firedScene = null;
				return false;
			}
			if (!ready || string.IsNullOrEmpty(scene))
			{
				return false;
			}
			if (string.Equals(scene, _firedScene, StringComparison.Ordinal))
			{
				return false;
			}
			_firedScene = scene;
			return true;
		}

		public void Reset()
		{
			_firedScene = null;
		}
	}
	public static class OutOfRoomReset
	{
		public static bool ShouldReset(int pendingCount, int helloedCount, int peerCount, int channelReadyCount)
		{
			if (pendingCount <= 0 && helloedCount <= 0 && peerCount <= 0)
			{
				return channelReadyCount > 0;
			}
			return true;
		}
	}
	public struct SimEnvelope
	{
		public string Channel;

		public string Verb;

		public int Seq;

		public string Extra;

		public string Payload;
	}
	public sealed class SimLink
	{
		private struct Entry
		{
			public SimEnvelope Env;

			public double Due;

			public long Order;
		}

		private readonly List<Entry> _queue = new List<Entry>();

		private readonly Random _rng;

		private readonly int _delayMs;

		private readonly int _jitterMs;

		private readonly int _dropPct;

		private readonly bool _ordered;

		private double _lastDue;

		private long _order;

		public int Enqueued { get; private set; }

		public int Dropped { get; private set; }

		public int Delivered { get; private set; }

		public int PendingCount => _queue.Count;

		public SimLink(int delayMs, int jitterMs, int dropPct, bool ordered, int seed)
		{
			_delayMs = ((delayMs >= 0) ? delayMs : 0);
			_jitterMs = ((jitterMs >= 0) ? jitterMs : 0);
			_dropPct = ((dropPct >= 0) ? ((dropPct > 100) ? 100 : dropPct) : 0);
			_ordered = ordered;
			_rng = new Random(seed);
		}

		public bool Enqueue(SimEnvelope env, double now)
		{
			if (_dropPct > 0 && _rng.Next(100) < _dropPct)
			{
				Dropped++;
				return false;
			}
			double num = now + (double)(_delayMs + ((_jitterMs > 0) ? _rng.Next(_jitterMs + 1) : 0)) / 1000.0;
			if (_ordered && num < _lastDue)
			{
				num = _lastDue;
			}
			_lastDue = (_ordered ? num : Math.Max(_lastDue, num));
			_queue.Add(new Entry
			{
				Env = env,
				Due = num,
				Order = _order++
			});
			Enqueued++;
			return true;
		}

		public List<SimEnvelope> DrainDue(double now)
		{
			List<Entry> list = null;
			for (int num = _queue.Count - 1; num >= 0; num--)
			{
				if (!(_queue[num].Due > now))
				{
					List<Entry> obj = list ?? new List<Entry>();
					list = obj;
					obj.Add(_queue[num]);
					_queue.RemoveAt(num);
				}
			}
			if (list == null)
			{
				return null;
			}
			list.Sort((Entry a, Entry b) => (a.Due == b.Due) ? a.Order.CompareTo(b.Order) : a.Due.CompareTo(b.Due));
			List<SimEnvelope> list2 = new List<SimEnvelope>(list.Count);
			foreach (Entry item in list)
			{
				list2.Add(item.Env);
			}
			Delivered += list2.Count;
			return list2;
		}

		public void Clear()
		{
			_queue.Clear();
			_lastDue = 0.0;
		}

		public string Describe()
		{
			return $"delay={_delayMs}ms jitter={_jitterMs}ms drop={_dropPct}% " + string.Format("{0} queued={1} dropped={2} ", _ordered ? "ordered" : "unordered", Enqueued, Dropped) + $"delivered={Delivered} pending={_queue.Count}";
		}
	}
	public enum StoreAuthorityKind
	{
		Master,
		Owner,
		PeerOwned
	}
	public static class StoreRoles
	{
		public static HandlerRole For(StoreAuthorityKind kind)
		{
			return kind switch
			{
				StoreAuthorityKind.Master => HandlerRole.RunOnMasterOnly, 
				StoreAuthorityKind.PeerOwned => HandlerRole.SenderMustNotBeSelf, 
				_ => HandlerRole.SenderMustBeMaster | HandlerRole.SenderMustNotBeSelf, 
			};
		}

		public static bool KeyFromSender(StoreAuthorityKind kind)
		{
			return kind == StoreAuthorityKind.PeerOwned;
		}

		public static bool BroadcastsToOthers(StoreAuthorityKind kind)
		{
			if (kind != StoreAuthorityKind.Owner)
			{
				return kind == StoreAuthorityKind.PeerOwned;
			}
			return true;
		}

		public static bool OwnerBindingApplies(StoreAuthorityKind kind)
		{
			return kind == StoreAuthorityKind.Master;
		}
	}
	public static class TimeoutConfig
	{
		public const int Vanilla = 10000;

		public static int Resolve(int configured, out bool negativeWasInvalid)
		{
			negativeWasInvalid = configured < 0;
			if (configured <= 0)
			{
				return 0;
			}
			return configured;
		}

		public static bool Armed(int configured)
		{
			bool negativeWasInvalid;
			return Resolve(configured, out negativeWasInvalid) > 0;
		}
	}
	public sealed class TraceRing
	{
		public struct Entry
		{
			public double T;

			public string Line;
		}

		private readonly Entry[] _ring;

		private int _next;

		public int Capacity => _ring.Length;

		public TraceRing(int capacity = 32)
		{
			if (capacity < 1)
			{
				capacity = 1;
			}
			_ring = new Entry[capacity];
		}

		public void Add(double now, string line)
		{
			_ring[_next] = new Entry
			{
				T = now,
				Line = line
			};
			_next = (_next + 1) % _ring.Length;
		}

		public IEnumerable<Entry> Ordered()
		{
			for (int i = 0; i < _ring.Length; i++)
			{
				Entry entry = _ring[(_next + i) % _ring.Length];
				if (entry.Line != null)
				{
					yield return entry;
				}
			}
		}
	}
	public struct ViewFacts
	{
		public int Views;

		public int NonZeroIds;

		public int AlreadyAwake;

		public int Deregistered;
	}
	public struct SurvivorFacts
	{
		public int Views;

		public int NetControls;

		public int Disarmed;

		public int Queued;

		public bool PinnedByCharacter;
	}
	public static class ViewHygiene
	{
		public const string RefusalNote = "DestroyImmediate was REFUSED, not attempted-and-failed: Unity silently refuses it inside animation events, physics trigger/contact callbacks, StateMachineBehaviour callbacks and render callbacks — it logs an error, returns, and never throws, so no try/catch can see it.";

		public static string Describe(in ViewFacts f)
		{
			return $"views={f.Views} ids={f.NonZeroIds} awake={f.AlreadyAwake} deregistered={f.Deregistered}";
		}

		public static string DescribeSurvivors(in SurvivorFacts f)
		{
			return $"pv={f.Views} ncc={f.NetControls} disarmed={f.Disarmed} queued={f.Queued}";
		}

		public static bool IsClean(in SurvivorFacts f)
		{
			if (f.Views == 0)
			{
				return f.NetControls == 0;
			}
			return false;
		}
	}
	public enum LeaseVerdict
	{
		Keep,
		ReleaseNow,
		ReleaseAgedOut,
		NotePersist,
		WarnLeak
	}
	public struct MuteResult
	{
		public bool Muted;

		public int ViewId;

		public string Error;
	}
	public static class LeasePolicy
	{
		public const float MaxParkSeconds = 300f;

		public const int MintWarnWatermark = 800;

		public static bool ShouldWarnMintCount(int outstanding)
		{
			return outstanding >= 800;
		}

		public static LeaseVerdict Verdict(bool bodyGone, float ageSeconds, bool viewLostId, bool warned, bool mayPersist)
		{
			if (bodyGone)
			{
				return LeaseVerdict.ReleaseNow;
			}
			if (ageSeconds < 300f)
			{
				return LeaseVerdict.Keep;
			}
			if (viewLostId)
			{
				return LeaseVerdict.ReleaseAgedOut;
			}
			if (warned)
			{
				return LeaseVerdict.Keep;
			}
			if (!mayPersist)
			{
				return LeaseVerdict.WarnLeak;
			}
			return LeaseVerdict.NotePersist;
		}
	}
	public sealed class LeaseEntry<TBody> where TBody : class
	{
		public int ViewId;

		public TBody Body;

		public float QueuedAt;

		public bool Warned;

		public bool MayPersist;
	}
	public sealed class ViewLedger<TBody> where TBody : class
	{
		private readonly List<LeaseEntry<TBody>> _entries = new List<LeaseEntry<TBody>>();

		public int Count => _entries.Count;

		public IReadOnlyList<LeaseEntry<TBody>> Entries => _entries;

		public LeaseEntry<TBody> Park(int viewId, TBody body, float now, bool mayPersist)
		{
			LeaseEntry<TBody> leaseEntry = new LeaseEntry<TBody>
			{
				ViewId = viewId,
				Body = body,
				QueuedAt = now,
				MayPersist = mayPersist
			};
			_entries.Add(leaseEntry);
			return leaseEntry;
		}

		public bool Remove(LeaseEntry<TBody> entry)
		{
			return _entries.Remove(entry);
		}

		public int DropAll()
		{
			int count = _entries.Count;
			_entries.Clear();
			return count;
		}

		public string DescribePending(string tag, float now, Func<TBody, string> bodyName)
		{
			if (_entries.Count == 0)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder($"{tag} {_entries.Count} viewID release(s) parked:");
			foreach (LeaseEntry<TBody> entry in _entries)
			{
				string text = bodyName?.Invoke(entry.Body);
				stringBuilder.Append(string.Format("\n  viewID={0} body='{1}' ", entry.ViewId, text ?? "<destroyed>") + $"age={now - entry.QueuedAt:0}s" + (entry.Warned ? (entry.MayPersist ? " PARKED(vanilla corpse — reserved until scene unload)" : " AGED-OUT(leak-warned)") : ""));
			}
			return stringBuilder.ToString();
		}
	}
	public sealed class WarnOnceSet
	{
		private readonly HashSet<string> _warned = new HashSet<string>(StringComparer.Ordinal);

		public int Count => _warned.Count;

		public static string Key(int actor, string channelId)
		{
			return actor + "|" + channelId;
		}

		public bool ShouldWarn(int actor, string channelId)
		{
			return _warned.Add(Key(actor, channelId));
		}

		public void Rearm(int actor, string channelId)
		{
			_warned.Remove(Key(actor, channelId));
		}

		public void Clear()
		{
			_warned.Clear();
		}
	}
}