using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using API;
using Agents;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using GameData;
using Globals;
using HarmonyLib;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using Player;
using ReplayRecorder.API;
using ReplayRecorder.API.Attributes;
using ReplayRecorder.BepInEx;
using ReplayRecorder.Core;
using ReplayRecorder.Exceptions;
using ReplayRecorder.Snapshot;
using ReplayRecorder.Snapshot.Exceptions;
using ReplayRecorder.Snapshot.Types;
using ReplayRecorder.Steam;
using SNetwork;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.Analytics;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("ReplayRecorder")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+294b80ff1430f8dce5692137fd10395c46294f59")]
[assembly: AssemblyProduct("ReplayRecorder")]
[assembly: AssemblyTitle("ReplayRecorder")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 API
{
	[HarmonyPatch(typeof(GameDataInit))]
	internal class GameDataInit_Patches
	{
		[HarmonyPatch("Initialize")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		public static void Initialize_Postfix()
		{
			Analytics.enabled = false;
		}
	}
	internal static class APILogger
	{
		private static readonly ManualLogSource logger;

		static APILogger()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			logger = new ManualLogSource("Rand-API");
			Logger.Sources.Add((ILogSource)(object)logger);
		}

		private static string Format(string module, object msg)
		{
			return $"[{module}]: {msg}";
		}

		public static void Info(string module, object data)
		{
			logger.LogMessage((object)Format(module, data));
		}

		public static void Verbose(string module, object data)
		{
		}

		public static void Log(object data)
		{
			logger.LogDebug((object)Format("ReplayRecorder", data));
		}

		public static void Debug(object data)
		{
			if (ConfigManager.Debug)
			{
				Log(data);
			}
		}

		public static void Warn(object data)
		{
			logger.LogWarning((object)Format("ReplayRecorder", data));
		}

		public static void Error(object data)
		{
			logger.LogError((object)Format("ReplayRecorder", data));
		}
	}
}
namespace ReplayRecorder
{
	internal class BufferPool
	{
		private Stack<ByteBuffer> pool = new Stack<ByteBuffer>();

		private readonly object lockObj = new object();

		private int size;

		private int inUse;

		public int Size => size;

		public int InUse => inUse;

		public void Shrink(int count)
		{
			while (pool.Count > count)
			{
				pool.Pop();
				size--;
			}
		}

		public ByteBuffer Checkout()
		{
			lock (lockObj)
			{
				inUse++;
				if (pool.Count == 0)
				{
					size++;
					return new ByteBuffer();
				}
				ByteBuffer byteBuffer = pool.Pop();
				byteBuffer.Clear();
				return byteBuffer;
			}
		}

		public void Release(ByteBuffer buffer)
		{
			lock (lockObj)
			{
				if (inUse != 0)
				{
					inUse--;
				}
				else
				{
					size++;
				}
				pool.Push(buffer);
			}
		}
	}
	internal static class Net
	{
		public delegate void onConnect(EndPoint endpoint);

		public delegate void onAccept(EndPoint endpoint);

		public delegate void onReceive(ArraySegment<byte> buffer, EndPoint endpoint);

		public delegate void onDisconnect(EndPoint endpoint);

		public delegate void onClose();

		public enum MessageType
		{
			StartGame,
			EndGame,
			LiveBytes,
			Acknowledgement,
			Connected,
			FailedToConnect
		}
	}
	internal class TCPServer : IDisposable
	{
		private class Connection : IDisposable
		{
			public enum State
			{
				waiting,
				reading
			}

			public Socket socket;

			public readonly EndPoint remoteEP;

			public byte[] recvBuffer;

			public byte[] sendBuffer;

			public byte[] messageBuffer;

			public SemaphoreSlim semaphoreSend = new SemaphoreSlim(1);

			public State state;

			public int messageSize;

			public int bytesWritten;

			public Connection(Socket socket, int bufferSize)
			{
				this.socket = socket;
				remoteEP = socket.RemoteEndPoint;
				messageBuffer = new byte[bufferSize];
				recvBuffer = new byte[bufferSize];
				sendBuffer = new byte[bufferSize];
			}

			public void Dispose()
			{
				semaphoreSend.Dispose();
				socket.Dispose();
			}
		}

		private readonly int bufferSize;

		private Socket? socket;

		public Net.onAccept? onAccept;

		public Net.onReceive? onReceive;

		public Net.onDisconnect? onDisconnect;

		public Net.onClose? onClose;

		private ConcurrentDictionary<EndPoint, Connection> acceptedConnections = new ConcurrentDictionary<EndPoint, Connection>();

		public ICollection<EndPoint> Connections => acceptedConnections.Keys;

		public TCPServer(int bufferSize = 8192)
		{
			if (bufferSize < 4)
			{
				throw new ArgumentException("Buffer size cannot be smaller than a message header [sizeof(int)].");
			}
			this.bufferSize = bufferSize;
		}

		private void Open()
		{
			if (socket != null)
			{
				Dispose();
			}
			socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
			socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.ReuseAddress, optionValue: true);
		}

		public EndPoint Bind(EndPoint remoteEP, int backlog = 5)
		{
			Open();
			socket.Bind(remoteEP);
			socket.Listen(backlog);
			Listen();
			return socket.LocalEndPoint;
		}

		private async Task Listen()
		{
			if (socket == null)
			{
				return;
			}
			Socket incoming = await socket.AcceptAsync().ConfigureAwait(continueOnCapturedContext: false);
			EndPoint remoteEndPoint = incoming.RemoteEndPoint;
			if (remoteEndPoint != null)
			{
				Connection connection = new Connection(incoming, bufferSize);
				acceptedConnections.AddOrUpdate(remoteEndPoint, connection, delegate(EndPoint key, Connection old)
				{
					incoming.Dispose();
					return old;
				});
				onAccept?.Invoke(remoteEndPoint);
				ListenTo(connection);
			}
			else
			{
				incoming.Dispose();
			}
			Listen();
		}

		private async Task ListenTo(Connection connection)
		{
			try
			{
				int num = await connection.socket.ReceiveAsync(connection.recvBuffer, SocketFlags.None).ConfigureAwait(continueOnCapturedContext: false);
				if (num > 0)
				{
					int num2 = num;
					int index = 0;
					do
					{
						switch (connection.state)
						{
						case Connection.State.waiting:
							connection.messageSize = BitHelper.ReadInt(connection.recvBuffer, ref index);
							connection.bytesWritten = 0;
							if (connection.messageSize > 0)
							{
								connection.state = Connection.State.reading;
							}
							break;
						case Connection.State.reading:
						{
							int num3 = num2;
							if (connection.bytesWritten + num2 > connection.messageSize)
							{
								num3 = connection.messageSize - connection.bytesWritten;
							}
							Array.Copy(connection.recvBuffer, index, connection.messageBuffer, connection.bytesWritten, num3);
							connection.bytesWritten += num3;
							index += num3;
							APILogger.Debug($"read: {connection.bytesWritten} {connection.messageSize}");
							if (connection.bytesWritten == connection.messageSize)
							{
								connection.state = Connection.State.waiting;
								onReceive?.Invoke(new ArraySegment<byte>(connection.messageBuffer, 0, connection.messageSize), connection.remoteEP);
							}
							break;
						}
						}
						num2 = num - index;
					}
					while (num2 > 0);
					ListenTo(connection);
				}
				else
				{
					Dispose(connection);
					onDisconnect?.Invoke(connection.remoteEP);
				}
			}
			catch (ObjectDisposedException)
			{
				Dispose(connection);
				onDisconnect?.Invoke(connection.remoteEP);
			}
		}

		private void Dispose(Connection connection)
		{
			acceptedConnections.Remove(connection.socket.RemoteEndPoint, out var _);
			connection.Dispose();
		}

		public async Task Send(ArraySegment<byte> data)
		{
			List<Task> list = new List<Task>();
			foreach (EndPoint key in acceptedConnections.Keys)
			{
				list.Add(SendTo(data, key));
			}
			await Task.WhenAll(list).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async Task RawSendTo(ArraySegment<byte> data, EndPoint remoteEP)
		{
			if (!acceptedConnections.TryGetValue(remoteEP, out Connection connection))
			{
				return;
			}
			await connection.semaphoreSend.WaitAsync().ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				int num = await connection.socket.SendAsync(data, SocketFlags.None).ConfigureAwait(continueOnCapturedContext: false);
				while (num < data.Count)
				{
					int num2 = num;
					num = num2 + await connection.socket.SendAsync(new ArraySegment<byte>(data.Array, data.Offset + num, data.Count - num), SocketFlags.None).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
			catch (SocketException)
			{
			}
			finally
			{
				connection.semaphoreSend.Release();
			}
		}

		public async Task SendTo(ArraySegment<byte> data, EndPoint remoteEP)
		{
			if (!acceptedConnections.TryGetValue(remoteEP, out Connection connection))
			{
				return;
			}
			await connection.semaphoreSend.WaitAsync().ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				if (data.Count <= int.MaxValue)
				{
					int size = 4 + data.Count;
					int num;
					for (num = connection.sendBuffer.Length; num < size; num *= 2)
					{
					}
					if (num > connection.sendBuffer.Length)
					{
						connection.sendBuffer = new byte[num];
					}
					int index = 0;
					BitHelper.WriteBytes(data.Count, (ArraySegment<byte>)connection.sendBuffer, ref index);
					Array.Copy(data.Array, data.Offset, connection.sendBuffer, index, data.Count);
					int num2 = await connection.socket.SendAsync(new ArraySegment<byte>(connection.sendBuffer, 0, size), SocketFlags.None).ConfigureAwait(continueOnCapturedContext: false);
					while (num2 < size)
					{
						int num3 = num2;
						num2 = num3 + await connection.socket.SendAsync(new ArraySegment<byte>(connection.sendBuffer, num2, size - num2), SocketFlags.None).ConfigureAwait(continueOnCapturedContext: false);
					}
				}
			}
			catch (SocketException)
			{
			}
			finally
			{
				connection.semaphoreSend.Release();
			}
		}

		public void Disconnect()
		{
			Dispose();
		}

		public void DisconnectClients()
		{
			foreach (Connection value in acceptedConnections.Values)
			{
				value.Dispose();
			}
			acceptedConnections.Clear();
		}

		public void Dispose()
		{
			if (socket != null)
			{
				DisconnectClients();
				socket.Dispose();
				socket = null;
				onClose?.Invoke();
			}
		}
	}
	[HarmonyPatch]
	internal class GameEventManager
	{
		[HarmonyPatch(typeof(ElevatorRide), "StartElevatorRide")]
		[HarmonyPostfix]
		private static void StartElevatorRide()
		{
			APILogger.Debug("Entered elevator!");
			SnapshotManager.OnElevatorStart();
			Replay.OnExpeditionStart?.Invoke();
		}

		[HarmonyPatch(typeof(RundownManager), "EndGameSession")]
		[HarmonyPrefix]
		private static void EndGameSession()
		{
			APILogger.Debug("Level ended!");
			SnapshotManager.OnExpeditionEnd();
		}

		[HarmonyPatch(typeof(SNet_SessionHub), "LeaveHub")]
		[HarmonyPrefix]
		private static void LeaveHub()
		{
			APILogger.Debug("Level ended!");
			SnapshotManager.OnExpeditionEnd();
		}

		[HarmonyPatch(typeof(GS_ReadyToStopElevatorRide), "Enter")]
		[HarmonyPostfix]
		private static void StopElevatorRide()
		{
			APILogger.Debug("Stop elevator!");
			Replay.OnElevatorStop?.Invoke();
		}

		[HarmonyPatch(typeof(PUI_LocalPlayerStatus), "UpdateBPM")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		public static void Initialize_Postfix(PUI_LocalPlayerStatus __instance)
		{
			if (ConfigManager.PerformanceDebug)
			{
				SnapshotInstance instance = SnapshotManager.GetInstance();
				TextMeshPro pulseText = __instance.m_pulseText;
				((TMP_Text)pulseText).text = ((TMP_Text)pulseText).text + $" | ({instance.pool.InUse}/{instance.pool.Size}) {Mathf.RoundToInt(instance.tickTime)}({Mathf.RoundToInt(instance.waitForWrite)})ms";
			}
		}
	}
	public static class Raudy
	{
		public static long Now => ((DateTimeOffset)DateTime.Now).ToUnixTimeMilliseconds();
	}
	public class BitHelperBufferTooLarge : Exception
	{
		public BitHelperBufferTooLarge(string message)
			: base(message)
		{
		}
	}
	public class ByteBuffer
	{
		internal ArraySegment<byte> _array = new byte[1024];

		internal int count;

		internal ArraySegment<byte> Array => new ArraySegment<byte>(_array.Array, _array.Offset, count);

		internal byte this[int index]
		{
			get
			{
				return _array[index];
			}
			set
			{
				_array[index] = value;
			}
		}

		public int Count => count;

		public ByteBuffer()
		{
			_array = new byte[1024];
		}

		public ByteBuffer(ArraySegment<byte> array)
		{
			_array = array;
		}

		internal void Clear()
		{
			count = 0;
		}

		internal void Copy(ByteBuffer other)
		{
			_array = new byte[other.count];
			System.Array.Copy(other._array.Array, other._array.Offset, _array.Array, _array.Offset, other.count);
		}

		internal void Reserve(int size, bool increment = false)
		{
			if (_array.Count - count < size)
			{
				byte[] array = new byte[Mathf.Max(_array.Count * 2, count + size)];
				System.Array.Copy(_array.Array, _array.Offset, array, 0, _array.Count);
				_array = array;
			}
			if (increment)
			{
				count += size;
			}
		}

		internal void Flush(FileStream fs)
		{
			if (ConfigManager.DebugTicks)
			{
				APILogger.Debug($"Flushed snapshot: {count} bytes.");
			}
			BitHelper.WriteBytes(count, fs);
			fs.Write(Array);
			count = 0;
		}

		internal async Task AsyncFlush(FileStream fs)
		{
			if (ConfigManager.DebugTicks)
			{
				APILogger.Debug($"Async Flushed snapshot: {count} bytes.");
			}
			BitHelper.WriteBytes(count, fs);
			await fs.WriteAsync(Array).ConfigureAwait(continueOnCapturedContext: false);
			count = 0;
		}

		internal void Shrink()
		{
			_array = new byte[1024];
			GC.Collect();
		}
	}
	public interface BufferWriteable
	{
		void Write(ByteBuffer buffer);
	}
	public static class BitHelper
	{
		public const int SizeOfHalf = 2;

		public const int SizeOfVector3 = 12;

		public const int SizeOfQuaternion = 13;

		public const int SizeOfHalfVector3 = 6;

		public const int SizeOfHalfQuaternion = 7;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint RotateLeft(uint value, int offset)
		{
			return (value << offset) | (value >> 32 - offset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint RotateRight(uint value, int offset)
		{
			return (value >> offset) | (value << 32 - offset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static long ReverseEndianness(long value)
		{
			return (long)ReverseEndianness((ulong)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int ReverseEndianness(int value)
		{
			return (int)ReverseEndianness((uint)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static short ReverseEndianness(short value)
		{
			return (short)ReverseEndianness((ushort)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static ushort ReverseEndianness(ushort value)
		{
			return (ushort)((value >> 8) + (value << 8));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint ReverseEndianness(uint value)
		{
			return RotateRight(value & 0xFF00FFu, 8) + RotateLeft(value & 0xFF00FF00u, 8);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static ulong ReverseEndianness(ulong value)
		{
			return ((ulong)ReverseEndianness((uint)value) << 32) + ReverseEndianness((uint)(value >> 32));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static void _WriteBytes(byte* source, int size, ArraySegment<byte> destination, ref int index)
		{
			int num = 0;
			while (num < size)
			{
				destination[index++] = source[num++];
			}
		}

		public static void WriteBytes(byte value, ArraySegment<byte> destination, ref int index)
		{
			destination[index++] = value;
		}

		public static void WriteBytes(bool value, ArraySegment<byte> destination, ref int index)
		{
			WriteBytes(value ? ((byte)1) : ((byte)0), destination, ref index);
		}

		public unsafe static void WriteBytes(ulong value, ArraySegment<byte> destination, ref int index)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 8, destination, ref index);
		}

		public unsafe static void WriteBytes(uint value, ArraySegment<byte> destination, ref int index)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 4, destination, ref index);
		}

		public unsafe static void WriteBytes(ushort value, ArraySegment<byte> destination, ref int index)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 2, destination, ref index);
		}

		public unsafe static void WriteBytes(long value, ArraySegment<byte> destination, ref int index)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 8, destination, ref index);
		}

		public unsafe static void WriteBytes(int value, ArraySegment<byte> destination, ref int index)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 4, destination, ref index);
		}

		public unsafe static void WriteBytes(short value, ArraySegment<byte> destination, ref int index)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 2, destination, ref index);
		}

		public unsafe static void WriteBytes(float value, ArraySegment<byte> destination, ref int index)
		{
			int value2 = *(int*)(&value);
			if (!BitConverter.IsLittleEndian)
			{
				value2 = ReverseEndianness(value2);
			}
			_WriteBytes((byte*)(&value2), 4, destination, ref index);
		}

		public static void WriteBytes(string value, ArraySegment<byte> destination, ref int index)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(value);
			if (bytes.Length > 65535)
			{
				throw new BitHelperBufferTooLarge($"String value is too large, byte length must be smaller than {65535}.");
			}
			WriteBytes((ushort)bytes.Length, destination, ref index);
			Array.Copy(bytes, 0, destination.Array, destination.Offset + index, bytes.Length);
			index += bytes.Length;
		}

		public static int SizeOfString(string value)
		{
			return 2 + Encoding.UTF8.GetBytes(value).Length;
		}

		public static void WriteBytes(ArraySegment<byte> buffer, ArraySegment<byte> destination, ref int index)
		{
			WriteBytes(buffer.Count, destination, ref index);
			Array.Copy(buffer.Array, buffer.Offset, destination.Array, destination.Offset + index, buffer.Count);
			index += buffer.Count;
		}

		public static void WriteHalf(float value, ArraySegment<byte> destination, ref int index)
		{
			WriteBytes(FloatToHalf(value), destination, ref index);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static void _WriteBytes(byte* bytes, int size, ByteBuffer buffer)
		{
			buffer.Reserve(size);
			for (int i = 0; i < size; i++)
			{
				buffer[buffer.count++] = bytes[i];
			}
		}

		public static void WriteBytes(byte value, ByteBuffer buffer)
		{
			buffer.Reserve(1);
			buffer[buffer.count++] = value;
		}

		public static void WriteBytes(bool value, ByteBuffer buffer)
		{
			WriteBytes(value ? ((byte)1) : ((byte)0), buffer);
		}

		public unsafe static void WriteBytes(ulong value, ByteBuffer buffer)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 8, buffer);
		}

		public unsafe static void WriteBytes(uint value, ByteBuffer buffer)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 4, buffer);
		}

		public unsafe static void WriteBytes(ushort value, ByteBuffer buffer)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 2, buffer);
		}

		public unsafe static void WriteBytes(long value, ByteBuffer buffer)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 8, buffer);
		}

		public unsafe static void WriteBytes(int value, ByteBuffer buffer)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 4, buffer);
		}

		public unsafe static void WriteBytes(short value, ByteBuffer buffer)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 2, buffer);
		}

		public unsafe static void WriteBytes(float value, ByteBuffer buffer)
		{
			int value2 = *(int*)(&value);
			if (!BitConverter.IsLittleEndian)
			{
				value2 = ReverseEndianness(value2);
			}
			_WriteBytes((byte*)(&value2), 4, buffer);
		}

		public static void WriteBytes(string value, ByteBuffer buffer)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(value);
			if (value.Length > 65535)
			{
				throw new BitHelperBufferTooLarge($"String value is too large, length must be smaller than {65535}.");
			}
			WriteBytes((ushort)bytes.Length, buffer);
			buffer.Reserve(bytes.Length);
			Array.Copy(bytes, 0, buffer._array.Array, buffer._array.Offset + buffer.count, bytes.Length);
			buffer.count += bytes.Length;
		}

		public static void WriteBytes(ArraySegment<byte> bytes, ByteBuffer buffer, bool includeCount = true)
		{
			if (includeCount)
			{
				WriteBytes(bytes.Count, buffer);
			}
			buffer.Reserve(bytes.Count);
			Array.Copy(bytes.Array, bytes.Offset, buffer._array.Array, buffer._array.Offset + buffer.count, bytes.Count);
			buffer.count += bytes.Count;
		}

		public static void WriteBytes(BufferWriteable writeable, ByteBuffer buffer)
		{
			writeable.Write(buffer);
		}

		public static void WriteHalf(float value, ByteBuffer buffer)
		{
			WriteBytes(FloatToHalf(value), buffer);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static void _WriteBytes(byte* bytes, int size, FileStream fs)
		{
			for (int i = 0; i < size; i++)
			{
				fs.WriteByte(bytes[i]);
			}
		}

		public static void WriteBytes(byte value, FileStream fs)
		{
			fs.WriteByte(value);
		}

		public static void WriteBytes(bool value, FileStream fs)
		{
			WriteBytes(value ? ((byte)1) : ((byte)0), fs);
		}

		public unsafe static void WriteBytes(ulong value, FileStream fs)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 8, fs);
		}

		public unsafe static void WriteBytes(uint value, FileStream fs)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 4, fs);
		}

		public unsafe static void WriteBytes(ushort value, FileStream fs)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 2, fs);
		}

		public unsafe static void WriteBytes(long value, FileStream fs)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 8, fs);
		}

		public unsafe static void WriteBytes(int value, FileStream fs)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 4, fs);
		}

		public unsafe static void WriteBytes(short value, FileStream fs)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			_WriteBytes((byte*)(&value), 2, fs);
		}

		public unsafe static void WriteBytes(float value, FileStream fs)
		{
			int value2 = *(int*)(&value);
			if (!BitConverter.IsLittleEndian)
			{
				value2 = ReverseEndianness(value2);
			}
			_WriteBytes((byte*)(&value2), 4, fs);
		}

		public static void WriteBytes(string value, FileStream fs)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(value);
			if (value.Length > 65535)
			{
				throw new BitHelperBufferTooLarge($"String value is too large, length must be smaller than {65535}.");
			}
			WriteBytes((ushort)bytes.Length, fs);
			fs.Write(bytes);
		}

		public static void WriteBytes(byte[] buffer, FileStream fs)
		{
			WriteBytes(buffer.Length, fs);
			fs.Write(buffer);
		}

		public static void WriteHalf(float value, FileStream fs)
		{
			WriteBytes(FloatToHalf(value), fs);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static uint AsUInt(float x)
		{
			return *(uint*)(&x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static float AsFloat(uint x)
		{
			return *(float*)(&x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static float HalfToFloat(ushort x)
		{
			int num = (x & 0x7C00) >> 10;
			int num2 = (x & 0x3FF) << 13;
			int num3 = (int)(AsUInt(num2) >> 23);
			return AsFloat((uint)(((x & 0x8000) << 16) | (Convert.ToInt32(num != 0) * ((num + 112 << 23) | num2)) | ((Convert.ToInt32(num == 0) & Convert.ToInt32(num2 != 0)) * ((num3 - 37 << 23) | ((num2 << 150 - num3) & 0x7FE000)))));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static ushort FloatToHalf(float x)
		{
			uint num = AsUInt(x) + 4096;
			uint num2 = (num & 0x7F800000) >> 23;
			uint num3 = num & 0x7FFFFFu;
			return (ushort)(((num & 0x80000000u) >> 16) | (Convert.ToInt32(num2 > 112) * (((num2 - 112 << 10) & 0x7C00) | (num3 >> 13))) | ((Convert.ToInt32(num2 < 113) & Convert.ToInt32(num2 > 101)) * ((8384512 + num3 >> (int)(125 - num2)) + 1 >> 1)) | (Convert.ToUInt32(num2 > 143) * 32767));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Quantize(float x)
		{
			return HalfToFloat(FloatToHalf(x));
		}

		public static byte ReadByte(ArraySegment<byte> source, ref int index)
		{
			return source[index++];
		}

		public static bool ReadBool(ArraySegment<byte> source, ref int index)
		{
			return ReadByte(source, ref index) != 0;
		}

		public unsafe static ulong ReadULong(ArraySegment<byte> source, ref int index)
		{
			fixed (byte* ptr = source.Array)
			{
				byte* num = ptr + source.Offset + index;
				index += 8;
				ulong num2 = *(ulong*)num;
				if (!BitConverter.IsLittleEndian)
				{
					num2 = ReverseEndianness(num2);
				}
				return num2;
			}
		}

		public unsafe static long ReadLong(ArraySegment<byte> source, ref int index)
		{
			fixed (byte* ptr = source.Array)
			{
				byte* num = ptr + source.Offset + index;
				index += 8;
				long num2 = *(long*)num;
				if (!BitConverter.IsLittleEndian)
				{
					num2 = ReverseEndianness(num2);
				}
				return num2;
			}
		}

		public unsafe static uint ReadUInt(ArraySegment<byte> source, ref int index)
		{
			fixed (byte* ptr = source.Array)
			{
				byte* num = ptr + source.Offset + index;
				index += 4;
				uint num2 = *(uint*)num;
				if (!BitConverter.IsLittleEndian)
				{
					num2 = ReverseEndianness(num2);
				}
				return num2;
			}
		}

		public unsafe static int ReadInt(ArraySegment<byte> source, ref int index)
		{
			fixed (byte* ptr = source.Array)
			{
				byte* num = ptr + source.Offset + index;
				index += 4;
				int num2 = *(int*)num;
				if (!BitConverter.IsLittleEndian)
				{
					num2 = ReverseEndianness(num2);
				}
				return num2;
			}
		}

		public unsafe static ushort ReadUShort(ArraySegment<byte> source, ref int index)
		{
			fixed (byte* ptr = source.Array)
			{
				byte* num = ptr + source.Offset + index;
				index += 2;
				ushort num2 = *(ushort*)num;
				if (!BitConverter.IsLittleEndian)
				{
					num2 = ReverseEndianness(num2);
				}
				return num2;
			}
		}

		public unsafe static short ReadShort(ArraySegment<byte> source, ref int index)
		{
			fixed (byte* ptr = source.Array)
			{
				byte* num = ptr + source.Offset + index;
				index += 2;
				short num2 = *(short*)num;
				if (!BitConverter.IsLittleEndian)
				{
					num2 = ReverseEndianness(num2);
				}
				return num2;
			}
		}

		public static float ReadHalf(ArraySegment<byte> source, ref int index)
		{
			return HalfToFloat(ReadUShort(source, ref index));
		}

		public unsafe static float ReadFloat(ArraySegment<byte> source, ref int index)
		{
			fixed (byte* ptr = source.Array)
			{
				byte* ptr2 = ptr + source.Offset + index;
				index += 4;
				if (!BitConverter.IsLittleEndian)
				{
					int num = ReverseEndianness(*(int*)ptr2);
					return *(float*)(&num);
				}
				return *(float*)ptr2;
			}
		}

		public static string ReadString(ArraySegment<byte> source, ref int index)
		{
			int num = ReadUShort(source, ref index);
			string @string = Encoding.UTF8.GetString(source.Array, source.Offset + index, num);
			index += num;
			return @string;
		}

		public static void WriteBytes(Vector3 value, byte[] destination, ref int index)
		{
			//IL_0000: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			WriteBytes(value.x, (ArraySegment<byte>)destination, ref index);
			WriteBytes(value.y, (ArraySegment<byte>)destination, ref index);
			WriteBytes(value.z, (ArraySegment<byte>)destination, ref index);
		}

		public static void WriteBytes(Quaternion value, byte[] destination, ref int index)
		{
			//IL_0002: 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: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			value = ((Quaternion)(ref value)).normalized;
			float num = value.x;
			byte b = 0;
			if (value.y > num)
			{
				num = value.y;
				b = 1;
			}
			if (value.z > num)
			{
				num = value.z;
				b = 2;
			}
			if (value.w > num)
			{
				num = value.w;
				b = 3;
			}
			WriteBytes(b, (ArraySegment<byte>)destination, ref index);
			switch (b)
			{
			case 0:
				if (value.x >= 0f)
				{
					WriteBytes(value.y, (ArraySegment<byte>)destination, ref index);
					WriteBytes(value.z, (ArraySegment<byte>)destination, ref index);
					WriteBytes(value.w, (ArraySegment<byte>)destination, ref index);
				}
				else
				{
					WriteBytes(0f - value.y, (ArraySegment<byte>)destination, ref index);
					WriteBytes(0f - value.z, (ArraySegment<byte>)destination, ref index);
					WriteBytes(0f - value.w, (ArraySegment<byte>)destination, ref index);
				}
				break;
			case 1:
				if (value.y >= 0f)
				{
					WriteBytes(value.x, (ArraySegment<byte>)destination, ref index);
					WriteBytes(value.z, (ArraySegment<byte>)destination, ref index);
					WriteBytes(value.w, (ArraySegment<byte>)destination, ref index);
				}
				else
				{
					WriteBytes(0f - value.x, (ArraySegment<byte>)destination, ref index);
					WriteBytes(0f - value.z, (ArraySegment<byte>)destination, ref index);
					WriteBytes(0f - value.w, (ArraySegment<byte>)destination, ref index);
				}
				break;
			case 2:
				if (value.z >= 0f)
				{
					WriteBytes(value.x, (ArraySegment<byte>)destination, ref index);
					WriteBytes(value.y, (ArraySegment<byte>)destination, ref index);
					WriteBytes(value.w, (ArraySegment<byte>)destination, ref index);
				}
				else
				{
					WriteBytes(0f - value.x, (ArraySegment<byte>)destination, ref index);
					WriteBytes(0f - value.y, (ArraySegment<byte>)destination, ref index);
					WriteBytes(0f - value.w, (ArraySegment<byte>)destination, ref index);
				}
				break;
			case 3:
				if (value.w >= 0f)
				{
					WriteBytes(value.x, (ArraySegment<byte>)destination, ref index);
					WriteBytes(value.y, (ArraySegment<byte>)destination, ref index);
					WriteBytes(value.z, (ArraySegment<byte>)destination, ref index);
				}
				else
				{
					WriteBytes(0f - value.x, (ArraySegment<byte>)destination, ref index);
					WriteBytes(0f - value.y, (ArraySegment<byte>)destination, ref index);
					WriteBytes(0f - value.z, (ArraySegment<byte>)destination, ref index);
				}
				break;
			}
		}

		public static void WriteBytes(Vector3 value, ByteBuffer buffer)
		{
			//IL_0000: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			WriteBytes(value.x, buffer);
			WriteBytes(value.y, buffer);
			WriteBytes(value.z, buffer);
		}

		public static void WriteBytes(Quaternion value, ByteBuffer buffer)
		{
			//IL_0002: 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: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_00b2: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: 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_00d9: 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)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			value = ((Quaternion)(ref value)).normalized;
			float num = value.x;
			byte b = 0;
			if (value.y > num)
			{
				num = value.y;
				b = 1;
			}
			if (value.z > num)
			{
				num = value.z;
				b = 2;
			}
			if (value.w > num)
			{
				num = value.w;
				b = 3;
			}
			WriteBytes(b, buffer);
			switch (b)
			{
			case 0:
				if (value.x >= 0f)
				{
					WriteBytes(value.y, buffer);
					WriteBytes(value.z, buffer);
					WriteBytes(value.w, buffer);
				}
				else
				{
					WriteBytes(0f - value.y, buffer);
					WriteBytes(0f - value.z, buffer);
					WriteBytes(0f - value.w, buffer);
				}
				break;
			case 1:
				if (value.y >= 0f)
				{
					WriteBytes(value.x, buffer);
					WriteBytes(value.z, buffer);
					WriteBytes(value.w, buffer);
				}
				else
				{
					WriteBytes(0f - value.x, buffer);
					WriteBytes(0f - value.z, buffer);
					WriteBytes(0f - value.w, buffer);
				}
				break;
			case 2:
				if (value.z >= 0f)
				{
					WriteBytes(value.x, buffer);
					WriteBytes(value.y, buffer);
					WriteBytes(value.w, buffer);
				}
				else
				{
					WriteBytes(0f - value.x, buffer);
					WriteBytes(0f - value.y, buffer);
					WriteBytes(0f - value.w, buffer);
				}
				break;
			case 3:
				if (value.w >= 0f)
				{
					WriteBytes(value.x, buffer);
					WriteBytes(value.y, buffer);
					WriteBytes(value.z, buffer);
				}
				else
				{
					WriteBytes(0f - value.x, buffer);
					WriteBytes(0f - value.y, buffer);
					WriteBytes(0f - value.z, buffer);
				}
				break;
			}
		}

		public static void WriteBytes(Vector3 value, FileStream fs)
		{
			//IL_0000: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			WriteBytes(value.x, fs);
			WriteBytes(value.y, fs);
			WriteBytes(value.z, fs);
		}

		public static void WriteBytes(Quaternion value, FileStream fs)
		{
			//IL_0002: 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: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_00b2: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: 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_00d9: 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)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			value = ((Quaternion)(ref value)).normalized;
			float num = value.x;
			byte b = 0;
			if (value.y > num)
			{
				num = value.y;
				b = 1;
			}
			if (value.z > num)
			{
				num = value.z;
				b = 2;
			}
			if (value.w > num)
			{
				num = value.w;
				b = 3;
			}
			WriteBytes(b, fs);
			switch (b)
			{
			case 0:
				if (value.x >= 0f)
				{
					WriteBytes(value.y, fs);
					WriteBytes(value.z, fs);
					WriteBytes(value.w, fs);
				}
				else
				{
					WriteBytes(0f - value.y, fs);
					WriteBytes(0f - value.z, fs);
					WriteBytes(0f - value.w, fs);
				}
				break;
			case 1:
				if (value.y >= 0f)
				{
					WriteBytes(value.x, fs);
					WriteBytes(value.z, fs);
					WriteBytes(value.w, fs);
				}
				else
				{
					WriteBytes(0f - value.x, fs);
					WriteBytes(0f - value.z, fs);
					WriteBytes(0f - value.w, fs);
				}
				break;
			case 2:
				if (value.z >= 0f)
				{
					WriteBytes(value.x, fs);
					WriteBytes(value.y, fs);
					WriteBytes(value.w, fs);
				}
				else
				{
					WriteBytes(0f - value.x, fs);
					WriteBytes(0f - value.y, fs);
					WriteBytes(0f - value.w, fs);
				}
				break;
			case 3:
				if (value.w >= 0f)
				{
					WriteBytes(value.x, fs);
					WriteBytes(value.y, fs);
					WriteBytes(value.z, fs);
				}
				else
				{
					WriteBytes(0f - value.x, fs);
					WriteBytes(0f - value.y, fs);
					WriteBytes(0f - value.z, fs);
				}
				break;
			}
		}

		public static Vector3 ReadVector3(ArraySegment<byte> source, ref int index)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(ReadFloat(source, ref index), ReadFloat(source, ref index), ReadFloat(source, ref index));
		}

		public static Quaternion ReadQuaternion(ArraySegment<byte> source, ref int index)
		{
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			byte b = ReadByte(source, ref index);
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			float num4 = 0f;
			switch (b)
			{
			case 0:
				num2 = ReadFloat(source, ref index);
				num3 = ReadFloat(source, ref index);
				num4 = ReadFloat(source, ref index);
				num = Mathf.Sqrt(Mathf.Clamp01(1f - num2 * num2 - num3 * num3 - num4 * num4));
				break;
			case 1:
				num = ReadFloat(source, ref index);
				num3 = ReadFloat(source, ref index);
				num4 = ReadFloat(source, ref index);
				num2 = Mathf.Sqrt(Mathf.Clamp01(1f - num * num - num3 * num3 - num4 * num4));
				break;
			case 2:
				num = ReadFloat(source, ref index);
				num2 = ReadFloat(source, ref index);
				num4 = ReadFloat(source, ref index);
				num3 = Mathf.Sqrt(Mathf.Clamp01(1f - num * num - num2 * num2 - num4 * num4));
				break;
			case 3:
				num = ReadFloat(source, ref index);
				num2 = ReadFloat(source, ref index);
				num3 = ReadFloat(source, ref index);
				num4 = Mathf.Sqrt(Mathf.Clamp01(1f - num * num - num2 * num2 - num3 * num3));
				break;
			}
			return new Quaternion(num, num2, num3, num4);
		}

		public static void WriteHalf(Vector3 value, ArraySegment<byte> destination, ref int index)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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)
			WriteHalf(value.x, destination, ref index);
			WriteHalf(value.y, destination, ref index);
			WriteHalf(value.z, destination, ref index);
		}

		public static void WriteHalf(Quaternion value, ArraySegment<byte> destination, ref int index)
		{
			//IL_0002: 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: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			value = ((Quaternion)(ref value)).normalized;
			float num = value.x;
			byte b = 0;
			if (value.y > num)
			{
				num = value.y;
				b = 1;
			}
			if (value.z > num)
			{
				num = value.z;
				b = 2;
			}
			if (value.w > num)
			{
				num = value.w;
				b = 3;
			}
			WriteBytes(b, destination, ref index);
			switch (b)
			{
			case 0:
				if (value.x >= 0f)
				{
					WriteHalf(value.y, destination, ref index);
					WriteHalf(value.z, destination, ref index);
					WriteHalf(value.w, destination, ref index);
				}
				else
				{
					WriteHalf(0f - value.y, destination, ref index);
					WriteHalf(0f - value.z, destination, ref index);
					WriteHalf(0f - value.w, destination, ref index);
				}
				break;
			case 1:
				if (value.y >= 0f)
				{
					WriteHalf(value.x, destination, ref index);
					WriteHalf(value.z, destination, ref index);
					WriteHalf(value.w, destination, ref index);
				}
				else
				{
					WriteHalf(0f - value.x, destination, ref index);
					WriteHalf(0f - value.z, destination, ref index);
					WriteHalf(0f - value.w, destination, ref index);
				}
				break;
			case 2:
				if (value.z >= 0f)
				{
					WriteHalf(value.x, destination, ref index);
					WriteHalf(value.y, destination, ref index);
					WriteHalf(value.w, destination, ref index);
				}
				else
				{
					WriteHalf(0f - value.x, destination, ref index);
					WriteHalf(0f - value.y, destination, ref index);
					WriteHalf(0f - value.w, destination, ref index);
				}
				break;
			case 3:
				if (value.w >= 0f)
				{
					WriteHalf(value.x, destination, ref index);
					WriteHalf(value.y, destination, ref index);
					WriteHalf(value.z, destination, ref index);
				}
				else
				{
					WriteHalf(0f - value.x, destination, ref index);
					WriteHalf(0f - value.y, destination, ref index);
					WriteHalf(0f - value.z, destination, ref index);
				}
				break;
			}
		}

		public static void WriteHalf(Vector3 value, ByteBuffer buffer)
		{
			//IL_0000: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			WriteHalf(value.x, buffer);
			WriteHalf(value.y, buffer);
			WriteHalf(value.z, buffer);
		}

		public static void WriteHalf(Quaternion value, ByteBuffer buffer)
		{
			//IL_0002: 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: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_00b2: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: 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_00d9: 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)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			value = ((Quaternion)(ref value)).normalized;
			float num = value.x;
			byte b = 0;
			if (value.y > num)
			{
				num = value.y;
				b = 1;
			}
			if (value.z > num)
			{
				num = value.z;
				b = 2;
			}
			if (value.w > num)
			{
				num = value.w;
				b = 3;
			}
			WriteBytes(b, buffer);
			switch (b)
			{
			case 0:
				if (value.x >= 0f)
				{
					WriteHalf(value.y, buffer);
					WriteHalf(value.z, buffer);
					WriteHalf(value.w, buffer);
				}
				else
				{
					WriteHalf(0f - value.y, buffer);
					WriteHalf(0f - value.z, buffer);
					WriteHalf(0f - value.w, buffer);
				}
				break;
			case 1:
				if (value.y >= 0f)
				{
					WriteHalf(value.x, buffer);
					WriteHalf(value.z, buffer);
					WriteHalf(value.w, buffer);
				}
				else
				{
					WriteHalf(0f - value.x, buffer);
					WriteHalf(0f - value.z, buffer);
					WriteHalf(0f - value.w, buffer);
				}
				break;
			case 2:
				if (value.z >= 0f)
				{
					WriteHalf(value.x, buffer);
					WriteHalf(value.y, buffer);
					WriteHalf(value.w, buffer);
				}
				else
				{
					WriteHalf(0f - value.x, buffer);
					WriteHalf(0f - value.y, buffer);
					WriteHalf(0f - value.w, buffer);
				}
				break;
			case 3:
				if (value.w >= 0f)
				{
					WriteHalf(value.x, buffer);
					WriteHalf(value.y, buffer);
					WriteHalf(value.z, buffer);
				}
				else
				{
					WriteHalf(0f - value.x, buffer);
					WriteHalf(0f - value.y, buffer);
					WriteHalf(0f - value.z, buffer);
				}
				break;
			}
		}

		public static void WriteHalf(Vector3 value, FileStream fs)
		{
			//IL_0000: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			WriteHalf(value.x, fs);
			WriteHalf(value.y, fs);
			WriteHalf(value.z, fs);
		}

		public static void WriteHalf(Quaternion value, FileStream fs)
		{
			//IL_0002: 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: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_00b2: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: 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_00d9: 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)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			value = ((Quaternion)(ref value)).normalized;
			float num = value.x;
			byte b = 0;
			if (value.y > num)
			{
				num = value.y;
				b = 1;
			}
			if (value.z > num)
			{
				num = value.z;
				b = 2;
			}
			if (value.w > num)
			{
				num = value.w;
				b = 3;
			}
			WriteBytes(b, fs);
			switch (b)
			{
			case 0:
				if (value.x >= 0f)
				{
					WriteHalf(value.y, fs);
					WriteHalf(value.z, fs);
					WriteHalf(value.w, fs);
				}
				else
				{
					WriteHalf(0f - value.y, fs);
					WriteHalf(0f - value.z, fs);
					WriteHalf(0f - value.w, fs);
				}
				break;
			case 1:
				if (value.y >= 0f)
				{
					WriteHalf(value.x, fs);
					WriteHalf(value.z, fs);
					WriteHalf(value.w, fs);
				}
				else
				{
					WriteHalf(0f - value.x, fs);
					WriteHalf(0f - value.z, fs);
					WriteHalf(0f - value.w, fs);
				}
				break;
			case 2:
				if (value.z >= 0f)
				{
					WriteHalf(value.x, fs);
					WriteHalf(value.y, fs);
					WriteHalf(value.w, fs);
				}
				else
				{
					WriteHalf(0f - value.x, fs);
					WriteHalf(0f - value.y, fs);
					WriteHalf(0f - value.w, fs);
				}
				break;
			case 3:
				if (value.w >= 0f)
				{
					WriteHalf(value.x, fs);
					WriteHalf(value.y, fs);
					WriteHalf(value.z, fs);
				}
				else
				{
					WriteHalf(0f - value.x, fs);
					WriteHalf(0f - value.y, fs);
					WriteHalf(0f - value.z, fs);
				}
				break;
			}
		}

		public static Vector3 ReadHalfVector3(ArraySegment<byte> source, ref int index)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(ReadHalf(source, ref index), ReadHalf(source, ref index), ReadHalf(source, ref index));
		}

		public static Quaternion ReadHalfQuaternion(ArraySegment<byte> source, ref int index)
		{
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			byte b = ReadByte(source, ref index);
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			float num4 = 0f;
			switch (b)
			{
			case 0:
				num2 = ReadHalf(source, ref index);
				num3 = ReadHalf(source, ref index);
				num4 = ReadHalf(source, ref index);
				num = Mathf.Sqrt(Mathf.Clamp01(1f - num2 * num2 - num3 * num3 - num4 * num4));
				break;
			case 1:
				num = ReadHalf(source, ref index);
				num3 = ReadHalf(source, ref index);
				num4 = ReadHalf(source, ref index);
				num2 = Mathf.Sqrt(Mathf.Clamp01(1f - num * num - num3 * num3 - num4 * num4));
				break;
			case 2:
				num = ReadHalf(source, ref index);
				num2 = ReadHalf(source, ref index);
				num4 = ReadHalf(source, ref index);
				num3 = Mathf.Sqrt(Mathf.Clamp01(1f - num * num - num2 * num2 - num4 * num4));
				break;
			case 3:
				num = ReadHalf(source, ref index);
				num2 = ReadHalf(source, ref index);
				num3 = ReadHalf(source, ref index);
				num4 = Mathf.Sqrt(Mathf.Clamp01(1f - num * num - num2 * num2 - num3 * num3));
				break;
			}
			return new Quaternion(num, num2, num3, num4);
		}
	}
	public static class Replay
	{
		public static Action? OnExpeditionEnd;

		public static Action? OnExpeditionStart;

		public static Action? OnElevatorStop;

		public static Action? OnGameplayStart;

		public static Action? OnHeaderCompletion;

		public static Action? OnTick;

		public static Dictionary<Type, Action<long, ReplayEvent>?> EventHooks = new Dictionary<Type, Action<long, ReplayEvent>>();

		public static Dictionary<Type, Action<long, ReplayDynamic>?> SpawnHooks = new Dictionary<Type, Action<long, ReplayDynamic>>();

		public static Dictionary<Type, Action<long, ReplayDynamic>?> DespawnHooks = new Dictionary<Type, Action<long, ReplayDynamic>>();

		public static Dictionary<Type, Action<long, ReplayDynamic>?> DynamicHooks = new Dictionary<Type, Action<long, ReplayDynamic>>();

		public static Dictionary<Type, Action<long, ReplayDynamic>?> DirtyDynamicHooks = new Dictionary<Type, Action<long, ReplayDynamic>>();

		public static float tickRate => SnapshotManager.GetInstance().tickRate;

		public static bool Ready => SnapshotManager.Ready;

		public static bool Active => SnapshotManager.Active;

		private static Delegate CreateCompatibleDelegate(MethodInfo methodInfo, Type delegateType)
		{
			ParameterInfo[] parameters2 = methodInfo.GetParameters();
			ParameterInfo[] parameters3 = delegateType.GetMethod("Invoke").GetParameters();
			ParameterExpression[] parameters = parameters3.Select((ParameterInfo p) => Expression.Parameter(p.ParameterType, p.Name)).ToArray();
			UnaryExpression[] array = parameters2.Select((ParameterInfo mp, int i) => Expression.Convert(parameters[i], mp.ParameterType)).ToArray();
			Expression[] arguments = array;
			MethodCallExpression body = Expression.Call(null, methodInfo, arguments);
			return Expression.Lambda(delegateType, body, parameters).Compile();
		}

		private static void RegisterMethods(Type t)
		{
			foreach (MethodInfo item in from m in t.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
				where m.GetCustomAttribute<ReplayOnExpeditionEnd>() != null || m.GetCustomAttribute<ReplayInit>() != null || m.GetCustomAttribute<ReplayTick>() != null || m.GetCustomAttribute<ReplayOnHeaderCompletion>() != null || m.GetCustomAttribute<ReplayOnGameplayStart>() != null || m.GetCustomAttribute<ReplayOnElevatorStop>() != null || m.GetCustomAttribute<ReplayHook>() != null || m.GetCustomAttribute<ReplaySpawnHook>() != null || m.GetCustomAttribute<ReplayDespawnHook>() != null
				select m)
			{
				if (item.IsStatic)
				{
					try
					{
						string value = "ReplayOnExpeditionEnd";
						ReplayHook customAttribute = item.GetCustomAttribute<ReplayHook>();
						ReplaySpawnHook customAttribute2 = item.GetCustomAttribute<ReplaySpawnHook>();
						ReplayDespawnHook customAttribute3 = item.GetCustomAttribute<ReplayDespawnHook>();
						if (customAttribute != null)
						{
							value = "ReplayHook";
							if (customAttribute.type.IsAssignableTo(typeof(ReplayEvent)))
							{
								Action<long, ReplayEvent> action = (Action<long, ReplayEvent>)CreateCompatibleDelegate(item, typeof(Action<long, ReplayEvent>));
								if (!EventHooks.ContainsKey(customAttribute.type))
								{
									EventHooks.Add(customAttribute.type, action);
								}
								else
								{
									Dictionary<Type, Action<long, ReplayEvent>> eventHooks = EventHooks;
									Type type = customAttribute.type;
									eventHooks[type] = (Action<long, ReplayEvent>)Delegate.Combine(eventHooks[type], action);
								}
							}
							else if (customAttribute.type.IsAssignableTo(typeof(ReplayDynamic)))
							{
								Action<long, ReplayDynamic> action2 = (Action<long, ReplayDynamic>)CreateCompatibleDelegate(item, typeof(Action<long, ReplayDynamic>));
								if (customAttribute.triggerOnlyWhenDirty)
								{
									if (!DirtyDynamicHooks.ContainsKey(customAttribute.type))
									{
										DirtyDynamicHooks.Add(customAttribute.type, action2);
									}
									else
									{
										Dictionary<Type, Action<long, ReplayDynamic>> dirtyDynamicHooks = DirtyDynamicHooks;
										Type type = customAttribute.type;
										dirtyDynamicHooks[type] = (Action<long, ReplayDynamic>)Delegate.Combine(dirtyDynamicHooks[type], action2);
									}
								}
								else if (!DynamicHooks.ContainsKey(customAttribute.type))
								{
									DynamicHooks.Add(customAttribute.type, action2);
								}
								else
								{
									Dictionary<Type, Action<long, ReplayDynamic>> dirtyDynamicHooks = DynamicHooks;
									Type type = customAttribute.type;
									dirtyDynamicHooks[type] = (Action<long, ReplayDynamic>)Delegate.Combine(dirtyDynamicHooks[type], action2);
								}
							}
							else
							{
								APILogger.Error($"Failed to register method '{item}': Type '{customAttribute.type}' is not a valid ReplayDynamic / ReplayEvent.");
							}
						}
						else if (customAttribute2 != null)
						{
							value = "ReplaySpawnHook";
							if (customAttribute2.type.IsAssignableTo(typeof(ReplayDynamic)))
							{
								Action<long, ReplayDynamic> action3 = (Action<long, ReplayDynamic>)CreateCompatibleDelegate(item, typeof(Action<long, ReplayDynamic>));
								if (!SpawnHooks.ContainsKey(customAttribute2.type))
								{
									SpawnHooks.Add(customAttribute2.type, action3);
								}
								else
								{
									Dictionary<Type, Action<long, ReplayDynamic>> dirtyDynamicHooks = SpawnHooks;
									Type type = customAttribute2.type;
									dirtyDynamicHooks[type] = (Action<long, ReplayDynamic>)Delegate.Combine(dirtyDynamicHooks[type], action3);
								}
							}
							else
							{
								APILogger.Error($"Failed to register method '{item}': Type '{customAttribute2.type}' is not a valid ReplayDynamic.");
							}
						}
						else if (customAttribute3 != null)
						{
							value = "ReplayDespawnHook";
							if (customAttribute3.type.IsAssignableTo(typeof(ReplayDynamic)))
							{
								Action<long, ReplayDynamic> action4 = (Action<long, ReplayDynamic>)CreateCompatibleDelegate(item, typeof(Action<long, ReplayDynamic>));
								if (!DespawnHooks.ContainsKey(customAttribute3.type))
								{
									DespawnHooks.Add(customAttribute3.type, action4);
								}
								else
								{
									Dictionary<Type, Action<long, ReplayDynamic>> dirtyDynamicHooks = DespawnHooks;
									Type type = customAttribute3.type;
									dirtyDynamicHooks[type] = (Action<long, ReplayDynamic>)Delegate.Combine(dirtyDynamicHooks[type], action4);
								}
							}
							else
							{
								APILogger.Error($"Failed to register method '{item}': Type '{customAttribute3.type}' is not a valid ReplayDynamic.");
							}
						}
						else if (item.GetCustomAttribute<ReplayInit>() != null)
						{
							value = "ReplayInit";
							OnExpeditionStart = (Action)Delegate.Combine(OnExpeditionStart, (Action)item.CreateDelegate(typeof(Action)));
						}
						else if (item.GetCustomAttribute<ReplayOnHeaderCompletion>() != null)
						{
							value = "ReplayOnHeaderCompletion";
							OnHeaderCompletion = (Action)Delegate.Combine(OnHeaderCompletion, (Action)item.CreateDelegate(typeof(Action)));
						}
						else if (item.GetCustomAttribute<ReplayOnGameplayStart>() != null)
						{
							value = "ReplayOnGameplayStart";
							OnGameplayStart = (Action)Delegate.Combine(OnGameplayStart, (Action)item.CreateDelegate(typeof(Action)));
						}
						else if (item.GetCustomAttribute<ReplayTick>() != null)
						{
							value = "ReplayTick";
							OnTick = (Action)Delegate.Combine(OnTick, (Action)item.CreateDelegate(typeof(Action)));
						}
						else if (item.GetCustomAttribute<ReplayOnElevatorStop>() != null)
						{
							value = "ReplayOnElevatorStop";
							OnElevatorStop = (Action)Delegate.Combine(OnElevatorStop, (Action)item.CreateDelegate(typeof(Action)));
						}
						else
						{
							OnExpeditionEnd = (Action)Delegate.Combine(OnExpeditionEnd, (Action)item.CreateDelegate(typeof(Action)));
						}
						APILogger.Debug($"Registered {value}: '{t.FullName}.{item.Name}'");
					}
					catch (Exception value2)
					{
						APILogger.Error($"Failed to register method '{item}': {value2}");
					}
				}
				else
				{
					APILogger.Error($"Replay attributes can only be applied to static methods. '{item}' is not static.");
				}
			}
		}

		public static void RegisterAll()
		{
			Type[] types = Assembly.GetCallingAssembly().GetTypes();
			foreach (Type type in types)
			{
				if (type.GetCustomAttribute<ReplayData>() != null)
				{
					RegisterType(type);
				}
				RegisterMethods(type);
			}
		}

		public static void RegisterAll(Type type)
		{
			Type[] nestedTypes = type.GetNestedTypes(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (Type type2 in nestedTypes)
			{
				if (type.GetCustomAttribute<ReplayData>() != null)
				{
					RegisterType(type2);
				}
				RegisterMethods(type2);
				RegisterAll(type2);
			}
		}

		public static void RegisterType(Type type)
		{
			ReplayData customAttribute = type.GetCustomAttribute<ReplayData>();
			if (customAttribute == null)
			{
				throw new ReplayTypeNotCompatible($"Type '{type}' is not a valid ReplayData type.");
			}
			SnapshotManager.types.RegisterType(customAttribute, type);
		}

		[HideFromIl2Cpp]
		public static void Configure<T>(int tickRate = 1, int max = int.MaxValue) where T : ReplayDynamic
		{
			SnapshotManager.GetInstance().Configure<T>(tickRate, max);
		}

		[HideFromIl2Cpp]
		public static bool Trigger(ReplayEvent e)
		{
			return SnapshotManager.GetInstance().Trigger(e);
		}

		[HideFromIl2Cpp]
		public static void Trigger(ReplayHeader header)
		{
			SnapshotManager.GetInstance().Trigger(header);
		}

		[HideFromIl2Cpp]
		public static bool Has(ReplayDynamic dynamic)
		{
			return SnapshotManager.GetInstance().Has(dynamic);
		}

		[HideFromIl2Cpp]
		public static bool Has<T>(int id) where T : ReplayDynamic
		{
			return SnapshotManager.GetInstance().Has(typeof(T), id);
		}

		[HideFromIl2Cpp]
		public static T Get<T>(int id) where T : ReplayDynamic
		{
			return (T)SnapshotManager.GetInstance().Get(typeof(T), id);
		}

		[HideFromIl2Cpp]
		public static bool TryGet<T>(int id, [NotNullWhen(true)] out T dynamic) where T : ReplayDynamic
		{
			if (Has<T>(id))
			{
				dynamic = Get<T>(id);
				return true;
			}
			dynamic = null;
			return false;
		}

		[HideFromIl2Cpp]
		public static void Clear<T>() where T : ReplayDynamic
		{
			SnapshotManager.GetInstance().Clear(typeof(T));
		}

		[HideFromIl2Cpp]
		public static void Spawn(ReplayDynamic dynamic, bool errorOnDuplicate = true)
		{
			SnapshotManager.GetInstance().Spawn(dynamic, errorOnDuplicate);
		}

		[HideFromIl2Cpp]
		public static void Despawn(ReplayDynamic dynamic, bool errorOnNotFound = true)
		{
			SnapshotManager.GetInstance().Despawn(dynamic, errorOnNotFound);
		}

		[HideFromIl2Cpp]
		public static bool TryDespawn<T>(int id) where T : ReplayDynamic
		{
			if (Has<T>(id))
			{
				Despawn(Get<T>(id));
				return true;
			}
			return false;
		}
	}
	public static class Utils
	{
		public const BindingFlags AnyBindingFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		public static string RemoveHTMLTags(string content)
		{
			return Regex.Replace(content, "<[^>]*>", "");
		}

		public static string RemoveInvalidCharacters(string content, char replace = '_', bool isFullPath = true)
		{
			if (string.IsNullOrEmpty(content))
			{
				return content;
			}
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			int num = content.IndexOfAny(invalidFileNameChars);
			if (num >= 0)
			{
				StringBuilder stringBuilder = new StringBuilder(content);
				while (num >= 0)
				{
					if (!isFullPath || (stringBuilder[num] != ':' && stringBuilder[num] != '\\' && stringBuilder[num] != '/'))
					{
						stringBuilder[num] = replace;
					}
					num = content.IndexOfAny(invalidFileNameChars, num + 1);
				}
				return stringBuilder.ToString();
			}
			return content;
		}
	}
}
namespace ReplayRecorder.Steam
{
	internal class rSteamClient : IDisposable
	{
		public SteamNet.clientOnAccept? onAccept;

		public SteamNet.clientOnReceive? onReceive;

		public SteamNet.clientOnClose? onClose;

		public SteamNet.clientOnFail? onFail;

		internal static HashSet<HSteamNetConnection> localClients = new HashSet<HSteamNetConnection>();

		private bool running = true;

		private Task? receiveTask;

		private HSteamNetConnection connection;

		private SteamNetworkingIdentity identity;

		private Callback<SteamNetConnectionStatusChangedCallback_t> cb_OnConnectionStatusChanged;

		public readonly EndPoint associatedEndPoint;

		private bool connected;

		public rSteamClient(ulong steamid, EndPoint associatedEndPoint)
		{
			//IL_001a: 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_0040: 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)
			this.associatedEndPoint = associatedEndPoint;
			identity = default(SteamNetworkingIdentity);
			((SteamNetworkingIdentity)(ref identity)).SetSteamID(new CSteamID(steamid));
			connection = SteamNetworkingSockets.ConnectP2P(ref identity, 0, 0, (SteamNetworkingConfigValue_t[])(object)new SteamNetworkingConfigValue_t[0]);
			cb_OnConnectionStatusChanged = Callback<SteamNetConnectionStatusChangedCallback_t>.Create((DispatchDelegate<SteamNetConnectionStatusChangedCallback_t>)OnConnectionStatusChanged);
		}

		private async Task ReceiveMessages()
		{
			IntPtr[] messageBuffer = new IntPtr[10];
			int numMessages;
			do
			{
				numMessages = SteamNetworkingSockets.ReceiveMessagesOnConnection(connection, messageBuffer, messageBuffer.Length);
				for (int i = 0; i < numMessages; i++)
				{
					SteamNetworkingMessage_t val = SteamNetworkingMessage_t.FromIntPtr(messageBuffer[i]);
					byte[] array = new byte[val.m_cbSize];
					Marshal.Copy(val.m_pData, array, 0, array.Length);
					onReceive?.Invoke(array, this);
					SteamNetworkingMessage_t.Release(messageBuffer[i]);
				}
				await Task.Delay(16);
			}
			while (numMessages >= 0 && running);
		}

		private void OnConnectionStatusChanged(SteamNetConnectionStatusChangedCallback_t callbackData)
		{
			//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_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected I4, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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)
			HSteamNetConnection hConn = callbackData.m_hConn;
			if (connection != hConn)
			{
				return;
			}
			SteamNetConnectionInfo_t info = callbackData.m_info;
			localClients.Add(hConn);
			ESteamNetworkingConnectionState eState = info.m_eState;
			switch (eState - 1)
			{
			case 0:
				APILogger.Debug($"[Client {hConn.m_HSteamNetConnection}] Connecting to: {((SteamNetConnectionInfo_t)(ref info)).m_szConnectionDescription}");
				connected = false;
				break;
			case 2:
				APILogger.Debug($"[Client {hConn.m_HSteamNetConnection}] Connection established: {((SteamNetConnectionInfo_t)(ref info)).m_szConnectionDescription}");
				onAccept?.Invoke(this);
				connected = true;
				receiveTask = ReceiveMessages();
				break;
			case 3:
			case 4:
				APILogger.Debug($"[Client {hConn.m_HSteamNetConnection}] Connection closed: {((SteamNetConnectionInfo_t)(ref info)).m_szEndDebug}, established: {connected}");
				if (!connected)
				{
					onFail?.Invoke(this);
				}
				Dispose();
				break;
			case 1:
				break;
			}
		}

		public void Dispose()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			running = false;
			receiveTask?.Wait();
			receiveTask?.Dispose();
			receiveTask = null;
			onClose?.Invoke(this);
			localClients.Remove(connection);
			SteamNetworkingSockets.CloseConnection(connection, 0, "Disconnect", false);
			cb_OnConnectionStatusChanged.Dispose();
		}
	}
	public class ConcurrentHashSet<T> : ConcurrentDictionary<T, byte> where T : notnull
	{
		private const byte DummyByte = 0;

		public bool Contains(T item)
		{
			return ContainsKey(item);
		}

		public bool Add(T item)
		{
			return TryAdd(item, 0);
		}

		public bool Remove(T item)
		{
			byte value;
			return TryRemove(item, out value);
		}
	}
	[HarmonyPatch]
	internal static class rSteamManager
	{
		private static bool initialized = false;

		public static ConcurrentHashSet<HSteamNetConnection> readyConnections = new ConcurrentHashSet<HSteamNetConnection>();

		public static SteamServer? Server { get; private set; } = null;


		[HarmonyPatch(typeof(SteamManager), "PostSetup")]
		[HarmonyPrefix]
		private static void Prefix_PostSetup()
		{
			if (!initialized)
			{
				initialized = true;
				SteamAPI.Init();
				GameServer.Init(2130706433u, (ushort)0, (ushort)0, (EServerMode)1, "0.0.0.1");
				SteamNetworkingUtils.InitRelayNetworkAccess();
				APILogger.Debug("Initialized Steamworks!");
				Server = new SteamServer();
				SteamServer? server = Server;
				server.onAccept = (SteamNet.onAccept)Delegate.Combine(server.onAccept, new SteamNet.onAccept(onAccept));
				SteamServer? server2 = Server;
				server2.onDisconnect = (SteamNet.onDisconnect)Delegate.Combine(server2.onDisconnect, new SteamNet.onDisconnect(onDisconnect));
				SteamServer? server3 = Server;
				server3.onClose = (SteamNet.onClose)Delegate.Combine(server3.onClose, new SteamNet.onClose(onClose));
			}
		}

		internal static void onAccept(HSteamNetConnection connection)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			if (Server == null)
			{
				return;
			}
			ByteBuffer byteBuffer = new ByteBuffer();
			BitHelper.WriteBytes(2, byteBuffer);
			BitHelper.WriteBytes((ushort)4, byteBuffer);
			Server.SendTo(connection, byteBuffer.Array);
			if ((Object)(object)SnapshotManager.instance != (Object)null)
			{
				SnapshotInstance instance = SnapshotManager.instance;
				if (instance.Active)
				{
					ByteBuffer byteBuffer2 = new ByteBuffer();
					BitHelper.WriteBytes(2, byteBuffer2);
					BitHelper.WriteBytes((ushort)0, byteBuffer2);
					Server.SendTo(connection, byteBuffer2.Array);
					Server.currentConnections[connection].queuePackets = true;
					Task.Run(delegate
					{
						//IL_009d: Unknown result type (might be due to invalid IL or missing references)
						//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
						if (Server != null)
						{
							byte[] array;
							do
							{
								instance.Flush();
								using FileStream fileStream = new FileStream(instance.fullpath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
								using MemoryStream memoryStream = new MemoryStream();
								fileStream.CopyTo(memoryStream);
								array = memoryStream.ToArray();
							}
							while (array.Length != instance.byteOffset);
							ByteBuffer byteBuffer3 = new ByteBuffer();
							BitHelper.WriteBytes(10 + array.Length, byteBuffer3);
							BitHelper.WriteBytes((ushort)2, byteBuffer3);
							BitHelper.WriteBytes(0, byteBuffer3);
							BitHelper.WriteBytes(array.Length, byteBuffer3);
							BitHelper.WriteBytes(array, byteBuffer3, includeCount: false);
							Server.SendTo(connection, byteBuffer3.Array, force: true);
							Server.currentConnections[connection].queuePackets = false;
						}
					});
				}
			}
			readyConnections.Add(connection);
		}

		internal static void onDisconnect(HSteamNetConnection connection)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			readyConnections.Remove(connection);
		}

		internal static void onClose()
		{
			readyConnections.Clear();
		}

		[HarmonyPatch(typeof(SteamManager), "Update")]
		[HarmonyPrefix]
		private static void Prefix_Update()
		{
			SteamAPI.RunCallbacks();
			SteamNetworkingSockets.RunCallbacks();
		}

		[HarmonyPatch(typeof(SNet_Core_STEAM), "OnQuit")]
		[HarmonyPostfix]
		private static void Postfix_OnQuit()
		{
			if (initialized)
			{
				Server?.Dispose();
				SteamAPI.Shutdown();
				GameServer.Shutdown();
				APILogger.Debug("Shutdown Steamworks!");
			}
		}
	}
	internal static class SteamNet
	{
		public delegate void onConnect(HSteamNetConnection connection);

		public delegate void onAccept(HSteamNetConnection connection);

		public delegate void clientOnAccept(rSteamClient connection);

		public delegate void onReceive(ArraySegment<byte> buffer, HSteamNetConnection connection);

		public delegate void clientOnReceive(ArraySegment<byte> buffer, rSteamClient connection);

		public delegate void onDisconnect(HSteamNetConnection connection);

		public delegate void onClose();

		public delegate void clientOnClose(rSteamClient connection);

		public delegate void clientOnFail(rSteamClient connection);
	}
	internal class SteamServer : IDisposable
	{
		public class Connection
		{
			public bool queuePackets;

			public ConcurrentQueue<ArraySegment<byte>> queue = new ConcurrentQueue<ArraySegment<byte>>();
		}

		public SteamNet.onAccept? onAccept;

		public SteamNet.onReceive? onReceive;

		public SteamNet.onDisconnect? onDisconnect;

		public SteamNet.onClose? onClose;

		private HSteamListenSocket server;

		private bool running = true;

		private Task? receiveTask;

		private Callback<SteamNetConnectionStatusChangedCallback_t> cb_OnConnectionStatusChanged;

		public ConcurrentDictionary<HSteamNetConnection, Connection> currentConnections = new ConcurrentDictionary<HSteamNetConnection, Connection>();

		private ConcurrentQueue<ArraySegment<byte>> resendQueue = new ConcurrentQueue<ArraySegment<byte>>();

		private List<ArraySegment<byte>> resendQueueBuffer = new List<ArraySegment<byte>>();

		public SteamServer()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			server = SteamNetworkingSockets.CreateListenSocketP2P(0, 0, (SteamNetworkingConfigValue_t[])(object)new SteamNetworkingConfigValue_t[0]);
			cb_OnConnectionStatusChanged = Callback<SteamNetConnectionStatusChangedCallback_t>.Create((DispatchDelegate<SteamNetConnectionStatusChangedCallback_t>)OnConnectionStatusChanged);
		}

		private async Task ReceiveMessages(HSteamNetConnection connection)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			IntPtr[] messageBuffer = new IntPtr[10];
			Connection conn = currentConnections[connection];
			int numMessages;
			do
			{
				numMessages = SteamNetworkingSockets.ReceiveMessagesOnConnection(connection, messageBuffer, messageBuffer.Length);
				for (int i = 0; i < numMessages; i++)
				{
					SteamNetworkingMessage_t val = SteamNetworkingMessage_t.FromIntPtr(messageBuffer[i]);
					byte[] array = new byte[val.m_cbSize];
					Marshal.Copy(val.m_pData, array, 0, array.Length);
					onReceive?.Invoke(array, connection);
					SteamNetworkingMessage_t.Release(messageBuffer[i]);
				}
				if (!resendQueue.IsEmpty)
				{
					SteamNetConnectionRealTimeStatus_t val2 = default(SteamNetConnectionRealTimeStatus_t);
					SteamNetConnectionRealTimeLaneStatus_t val3 = default(SteamNetConnectionRealTimeLaneStatus_t);
					if ((int)SteamNetworkingSockets.GetConnectionRealTimeStatus(connection, ref val2, 0, ref val3) == 1 && val2.m_cbPendingReliable + val2.m_cbSentUnackedReliable == 0)
					{
						ArraySegment<byte> result;
						while (resendQueue.TryDequeue(out result))
						{
							resendQueueBuffer.Add(result);
						}
						int j;
						for (j = 0; j < resendQueueBuffer.Count && SendTo(connection, resendQueueBuffer[j], force: false, dequeue: true); j++)
						{
						}
						for (; j < resendQueueBuffer.Count; j++)
						{
							resendQueue.Enqueue(resendQueueBuffer[j]);
						}
						resendQueueBuffer.Clear();
					}
				}
				if (!conn.queuePackets)
				{
					ArraySegment<byte> result2;
					while (conn.queue.TryDequeue(out result2))
					{
						SendTo(connection, result2);
					}
				}
				await Task.Delay(16);
			}
			while (numMessages >= 0 && running);
		}

		public void Send(ArraySegment<byte> data)
		{
			//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_001b: Unknown result type (might be due to invalid IL or missing references)
			foreach (HSteamNetConnection key in currentConnections.Keys)
			{
				SendTo(key, data);
			}
		}

		public bool SendTo(HSteamNetConnection connection, ArraySegment<byte> data, bool force = false, bool dequeue = false)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_00a5: 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)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			Connection connection2 = currentConnections[connection];
			if (connection2.queuePackets && !force)
			{
				connection2.queue.Enqueue(data);
				return true;
			}
			if (!dequeue && !resendQueue.IsEmpty)
			{
				resendQueue.Enqueue(data);
				return true;
			}
			int num = Mathf.CeilToInt((float)data.Count / 524288f);
			IntPtr[] array = new IntPtr[num];
			ArraySegment<byte>[] array2 = new ArraySegment<byte>[num];
			long[] array3 = new long[num];
			int num2 = 0;
			int num3 = 0;
			while (num2 < data.Count)
			{
				int num4 = Mathf.Min(data.Count - num2, 524288);
				IntPtr intPtr = SteamGameServerNetworkingUtils.AllocateMessage(num4);
				SteamNetworkingMessage_t val = SteamNetworkingMessage_t.FromIntPtr(intPtr);
				val.m_conn = connection;
				val.m_nFlags = 9;
				Marshal.Copy(data.Array, data.Offset + num2, val.m_pData, num4);
				array2[num3] = new ArraySegment<byte>(data.Array, data.Offset + num2, num4);
				num2 += num4;
				array[num3] = intPtr;
				num3++;
				Marshal.StructureToPtr<SteamNetworkingMessage_t>(val, intPtr, fDeleteOld: true);
			}
			SteamNetworkingSockets.SendMessages(num, array, array3);
			bool result = true;
			for (int i = 0; i < array3.Length; i++)
			{
				if (array3[i] < 0)
				{
					resendQueue.Enqueue(array2[i]);
					result = false;
				}
			}
			return result;
		}

		private void OnConnectionStatusChanged(SteamNetConnectionStatusChangedCallback_t callbackData)
		{
			//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_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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_0036: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_005b: Expected I4, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Invalid comparison between Unknown and I4
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			HSteamNetConnection hConn = callbackData.m_hConn;
			SteamNetConnectionInfo_t info = callbackData.m_info;
			if (info.m_hListenSocket != server || rSteamClient.localClients.Contains(hConn))
			{
				return;
			}
			ESteamNetworkingConnectionState eState = info.m_eState;
			switch (eState - 1)
			{
			case 0:
			{
				APILogger.Debug("[Server] Incoming connection from: " + ((SteamNetConnectionInfo_t)(ref info)).m_szConnectionDescription);
				ulong steamID = ((SteamNetworkingIdentity)(ref info.m_identityRemote)).GetSteamID64();
				if (steamID == SteamUser.GetSteamID().m_SteamID || ConfigManager.allowAnySpectator || ConfigManager.steamIDWhitelist.Contains(steamID))
				{
					EResult val = SteamNetworkingSockets.AcceptConnection(hConn);
					if ((int)val != 1)
					{
						APILogger.Debug($"[Server] Failed to accept connection: {val}");
						SteamNetworkingSockets.CloseConnection(hConn, 0, "Failed to accept", false);
					}
					else
					{
						APILogger.Warn($"[Server] Allowed {steamID} to spectate your lobby.");
					}
				}
				else
				{
					APILogger.Warn($"[Server] Rejected {steamID} from spectating your lobby.");
				}
				break;
			}
			case 2:
			{
				APILogger.Debug("[Server] Connection established: " + ((SteamNetConnectionInfo_t)(ref info)).m_szConnectionDescription);
				Connection conn = new Connection();
				currentConnections.AddOrUpdate(hConn, conn, (HSteamNetConnection key, Connection old) => conn);
				onAccept?.Invoke(hConn);
				receiveTask = ReceiveMessages(hConn);
				break;
			}
			case 3:
			case 4:
			{
				APILogger.Debug("[Server] Connection closed: " + ((SteamNetConnectionInfo_t)(ref info)).m_szEndDebug);
				currentConnections.Remove(hConn, out var _);
				onDisconnect?.Invoke(hConn);
				SteamNetworkingSockets.CloseConnection(hConn, 0, "Closed", false);
				break;
			}
			case 1:
				break;
			}
		}

		public void Dispose()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			running = false;
			receiveTask?.Wait();
			receiveTask?.Dispose();
			receiveTask = null;
			cb_OnConnectionStatusChanged.Dispose();
			SteamNetworkingSockets.CloseListenSocket(server);
			onClose?.Invoke();
			APILogger.Debug("[Server] Listen server closed.");
		}
	}
}
namespace ReplayRecorder.SNetUtils
{
	public class SNetUtils
	{
		internal static ushort currentRepKey;

		internal static int currentPacketIndex;

		internal static SNet_Player? currentSender;

		public static bool TryGetSender(SNet_Packet packet, [MaybeNullWhen(false)] out SNet_Player player)
		{
			if ((Object)(object)currentSender != (Object)null && packet.Replicator.Key == currentRepKey && packet.Index == currentPacketIndex)
			{
				player = currentSender;
				return true;
			}
			player = null;
			return false;
		}
	}
	[HarmonyPatch]
	internal class Patches
	{
		[HarmonyPatch(typeof(SNet_Replication), "RecieveBytes")]
		[HarmonyWrapSafe]
		[HarmonyPriority(700)]
		[HarmonyPrefix]
		private static void Prefix_RecieveBytes(Il2CppStructArray<byte> bytes, uint size, ulong messagerID)
		{
			IReplicator val = default(IReplicator);
			int currentPacketIndex = default(int);
			SNet_Player currentSender = default(SNet_Player);
			if (SNet.Replication.TryGetReplicator(bytes, ref val, ref currentPacketIndex) && SNet.Core.TryGetPlayer(messagerID, ref currentSender, false))
			{
				SNetUtils.currentSender = currentSender;
				SNetUtils.currentRepKey = val.Key;
				SNetUtils.currentPacketIndex = currentPacketIndex;
			}
		}

		[HarmonyPatch(typeof(SNet_Replication), "RecieveBytes")]
		[HarmonyWrapSafe]
		[HarmonyPriority(100)]
		[HarmonyPostfix]
		private static void Postfix_RecieveBytes(Il2CppStructArray<byte> bytes, uint size, ulong messagerID)
		{
			SNetUtils.currentSender = null;
			SNetUtils.currentRepKey = 0;
			SNetUtils.currentPacketIndex = 0;
		}
	}
}
namespace ReplayRecorder.Snapshot
{
	internal class SnapshotInstance : MonoBehaviour
	{
		private class EventWrapper
		{
			private ushort id;

			private ReplayEvent eventObj;

			internal ByteBuffer? eventBuffer;

			internal long now;

			public string? Debug => eventObj.Debug;

			public EventWrapper(long now, ReplayEvent e, ByteBuffer buffer)
			{
				this.now = now;
				eventObj = e;
				eventBuffer = buffer;
				e.Write(eventBuffer);
				id = SnapshotManager.types[e.GetType()];
			}

			~EventWrapper()
			{
				Dispose();
			}

			public void Dispose()
			{
				if (eventBuffer != null)
				{
					if ((Object)(object)SnapshotManager.instance != (Object)null)
					{
						SnapshotManager.instance.pool.Release(eventBuffer);
					}
					eventBuffer = null;
				}
			}

			public void Write(ByteBuffer buffer)
			{
				if (eventBuffer == null)
				{
					throw new Exception("Memory Buffer was disposed too early...");
				}
				if (ConfigManager.Debug && ConfigManager.DebugDynamics)
				{
					API