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.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
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 SNetwork;
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+1ce592b4a73a011d2f8b04df1c44cd0ef8bbeaa9")]
[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
		}
	}
	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 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)
		{
			APILogger.Debug($"Flushed snapshot: {count} bytes.");
			BitHelper.WriteBytes(count, fs);
			fs.Write(Array);
			count = 0;
		}

		internal async Task AsyncFlush(FileStream fs)
		{
			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 float tickRate => SnapshotManager.GetInstance().tickRate;

		public static bool Ready => SnapshotManager.Ready;

		public static bool Active => SnapshotManager.Active;

		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<ReplayReset>() != null || m.GetCustomAttribute<ReplayInit>() != null || m.GetCustomAttribute<ReplayTick>() != null || m.GetCustomAttribute<ReplayOnHeaderCompletion>() != null || m.GetCustomAttribute<ReplayOnGameplayStart>() != null || m.GetCustomAttribute<ReplayOnElevatorStop>() != null
				select m)
			{
				if (item.IsStatic)
				{
					try
					{
						string value = "ReplayReset";
						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: {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 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.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)
				{
					APILogger.Debug($"[Event: {eventObj.GetType().FullName}({SnapshotManager.types[eventObj.GetType()]})]{((eventObj.Debug != null) ? (": " + eventObj.Debug) : "")}");
				}
				BitHelper.WriteBytes(id, buffer);
				BitHelper.WriteBytes(eventBuffer.Array, buffer, includeCount: false);
			}
		}

		private class DynamicCollection : IEnumerable<ReplayDynamic>, IEnumerable
		{
			public int max = int.MaxValue;

			private int cycle;

			public int tickRate = 1;

			private int tick;

			private List<ReplayDynamic> _dynamics = new List<ReplayDynamic>();

			private List<ReplayDynamic> dynamics = new List<ReplayDynamic>();

			private Dictionary<int, ReplayDynamic> mapOfDynamics = new Dictionary<int, ReplayDynamic>();

			private SnapshotInstance instance;

			private bool handleRemoval;

			public Type Type { get; private set; }

			public ushort Id { get; private set; }

			public bool Tick
			{
				get
				{
					tick = (tick + 1) % Mathf.Clamp(tickRate, 1, int.MaxValue);
					return tick == 0;
				}
			}

			public DynamicCollection(Type type, SnapshotInstance instance)
			{
				this.instance = instance;
				if (!SnapshotManager.types.Contains(type))
				{
					throw new ReplayTypeDoesNotExist("Could not create DynamicCollection of type '" + type.FullName + "'.");
				}
				Type = type;
				Id = SnapshotManager.types[type];
			}

			public IEnumerator<ReplayDynamic> GetEnumerator()
			{
				foreach (ReplayDynamic value in mapOfDynamics.Values)
				{
					yield return value;
				}
			}

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

			[HideFromIl2Cpp]
			public bool Has(ReplayDynamic dynamic)
			{
				Type type = dynamic.GetType();
				if (!Type.IsAssignableFrom(type))
				{
					throw new ReplayIncompatibleType($"Cannot add '{type.FullName}' to DynamicCollection of type '{Type.FullName}'.");
				}
				return mapOfDynamics.ContainsKey(dynamic.id);
			}

			[HideFromIl2Cpp]
			public bool Has(int id)
			{
				return mapOfDynamics.ContainsKey(id);
			}

			[HideFromIl2Cpp]
			public ReplayDynamic Get(int id)
			{
				if (!mapOfDynamics.ContainsKey(id))
				{
					throw new ReplayDynamicDoesNotExist($"Cannot get dynamic of id '{id}'. Type: '{Type.FullName}'.");
				}
				return mapOfDynamics[id];
			}

			[HideFromIl2Cpp]
			public void Add(ReplayDynamic dynamic, bool errorOnDuplicate = true)
			{
				Type type = dynamic.GetType();
				if (!Type.IsAssignableFrom(type))
				{
					throw new ReplayIncompatibleType($"Cannot add '{type.FullName}' to DynamicCollection of type '{Type.FullName}'.");
				}
				if (mapOfDynamics.ContainsKey(dynamic.id))
				{
					if (errorOnDuplicate)
					{
						throw new ReplayDynamicAlreadyExists($"Dynamic [{dynamic.id}] already exists in DynamicCollection of type '{Type.FullName}'.");
					}
				}
				else
				{
					dynamics.Add(dynamic);
					mapOfDynamics.Add(dynamic.id, dynamic);
				}
			}

			[HideFromIl2Cpp]
			public void Remove(int id, bool errorOnNotFound = true)
			{
				if (!mapOfDynamics.ContainsKey(id))
				{
					if (errorOnNotFound)
					{
						throw new ReplayDynamicDoesNotExist($"Dynamic [{id}] does not exist in DynamicCollection of type '{Type.FullName}'.");
					}
				}
				else
				{
					handleRemoval = true;
					mapOfDynamics[id].remove = true;
					mapOfDynamics.Remove(id);
				}
			}

			[HideFromIl2Cpp]
			public void Remove(ReplayDynamic dynamic)
			{
				Type type = dynamic.GetType();
				if (!Type.IsAssignableFrom(type))
				{
					throw new ReplayIncompatibleType($"Cannot remove dynamic of type '{type.FullName}' from DynamicCollection of type '{Type.FullName}'.");
				}
				Remove(dynamic.id);
			}

			public int Write(ByteBuffer buffer)
			{
				if (tick != 0)
				{
					return 0;
				}
				int count = buffer.count;
				int num = 0;
				BitHelper.WriteBytes(Id, buffer);
				int index = buffer.count;
				buffer.Reserve(4, increment: true);
				bool flag = handleRemoval;
				handleRemoval = false;
				if (flag)
				{
					_dynamics.Clear();
				}
				for (int i = 0; i < dynamics.Count; i++)
				{
					cycle %= dynamics.Count;
					ReplayDynamic dynamic = dynamics[cycle++];
					bool active = dynamic.Active;
					if (num < max && (!dynamic.remove || tickRate == 1) && active && dynamic.IsDirty)
					{
						if (ConfigManager.Debug && ConfigManager.DebugDynamics)
						{
							APILogger.Debug($"[Dynamic: {dynamic.GetType().FullName}({SnapshotManager.types[dynamic.GetType()]})]{((dynamic.Debug != null) ? (": " + dynamic.Debug) : "")}");
						}
						int count2 = buffer.count;
						try
						{
							dynamic._Write(buffer);
							dynamic.Write(buffer);
							num++;
						}
						catch (Exception ex)
						{
							buffer.count = count2;
							if (!dynamic.remove)
							{
								instance.Despawn(dynamic);
								APILogger.Warn($"[DynamicCollection] Despawning due to Error {Type} {dynamic.id}");
								APILogger.Error($"Unexpected error occured whilst trying to write Dynamic[{Type}]({dynamic.id}) at [{instance.Now}ms]:\n{ex}\n{ex.StackTrace}");
							}
						}
					}
					if (!active && !dynamic.remove)
					{
						if (dynamics.Any((ReplayDynamic d) => (object)d != dynamic && d == dynamic && d.Active && !d.remove))
						{
							dynamic.remove = true;
							handleRemoval = true;
							APILogger.Warn($"[DynamicCollection] Silent Removal {Type} {dynamic.id}");
						}
						else
						{
							instance.Despawn(dynamic);
							APILogger.Warn($"[DynamicCollection] Forced Despawn {Type} {dynamic.id}");
						}
					}
					if (flag && !dynamic.remove)
					{
						_dynamics.Add(dynamic);
					}
				}
				if (flag)
				{
					List<ReplayDynamic> list = dynamics;
					dynamics = _dynamics;
					_dynamics = list;
				}
				if (num == 0)
				{
					buffer.count = count;
					return 0;
				}
				BitHelper.WriteBytes(num, buffer._array, ref index);
				if (ConfigManager.Debug)
				{
					APILogger.Debug($"[DynamicCollection: {Type.FullName}({SnapshotManager.types[Type]})]: {num} dynamics serialized.");
				}
				return num;
			}
		}

		private class DeltaState
		{
			internal List<EventWrapper> events = new List<EventWrapper>();

			internal Dictionary<Type, DynamicCollection> dynamics = new Dictionary<Type, DynamicCollection>();

			internal void Clear()
			{
				events.Clear();
				dynamics.Clear();
			}

			internal bool Write(long now, ByteBuffer bs)
			{
				BitHelper.WriteBytes((uint)now, bs);
				BitHelper.WriteBytes(events.Count, bs);
				for (int i = 0; i < events.Count; i++)
				{
					EventWrapper eventWrapper = events[i];
					long num = now - eventWrapper.now;
					if (num < 0)
					{
						num = 0L;
					}
					if (num > 65535)
					{
						APILogger.Warn($"Delta time of {num}ms is invalid. Max is {65535}ms.");
						num = 65535L;
					}
					BitHelper.WriteBytes((ushort)num, bs);
					eventWrapper.Write(bs);
					eventWrapper.Dispose();
				}
				bool flag = events.Count != 0;
				APILogger.Debug($"[Events] {events.Count} events written.");
				events.Clear();
				int num2 = 0;
				int index = bs.count;
				bs.Reserve(2, increment: true);
				foreach (DynamicCollection value in dynamics.Values)
				{
					try
					{
						if (value.Write(bs) > 0)
						{
							num2++;
						}
					}
					catch (Exception ex)
					{
						APILogger.Error($"Unexpected error occured whilst trying to write DynamicCollection[{value.Type}] at [{now}ms]:\n{ex}\n{ex.StackTrace}");
					}
				}
				BitHelper.WriteBytes((ushort)num2, bs._array, ref index);
				if (ConfigManager.Debug && ConfigManager.DebugDynamics)
				{
					APILogger.Debug($"Flushed {num2} dynamic collections.");
				}
				if (!flag)
				{
					return num2 != 0;
				}
				return true;
			}
		}

		private FileStream? fs;

		private int byteOffset;

		private DeltaState state = new DeltaState();

		private ByteBuffer buffer = new ByteBuffer();

		private ByteBuffer _buffer = new ByteBuffer();

		internal BufferPool pool = new BufferPool();

		private Task? writeTask;

		private long start;

		private bool completedHeader;

		private HashSet<Type> unwrittenHeaders = new HashSet<Type>();

		internal string fullpath = "replay.gtfo";

		internal string filename = "replay.gtfo";

		private Stopwatch stopwatch = new Stopwatch();

		private int bufferShrinkTick;

		private int peakInUse;

		internal float tickTime = 1f;

		internal float waitForWrite = 1f;

		private HashSet<ulong> alertedPlayers = new HashSet<ulong>();

		public float tickRate = 0.05f;

		private float timer;

		public bool Ready
		{
			get
			{
				if (Active)
				{
					return completedHeader;
				}
				return false;
			}
		}

		public bool Active => fs != null;

		private long Now => Raudy.Now - start;

		internal void Init()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (fs != null)
			{
				throw new ReplaySnapshotAlreadyInitialized();
			}
			start = Raudy.Now;
			pActiveExpedition activeExpeditionData = RundownManager.GetActiveExpeditionData();
			RundownDataBlock block = GameDataBlockBase<RundownDataBlock>.GetBlock(Global.RundownIdToLoad);
			ExpeditionInTierData expeditionData = block.GetExpeditionData(activeExpeditionData.tier, activeExpeditionData.expeditionIndex);
			string shortName = expeditionData.GetShortName(activeExpeditionData.expeditionIndex);
			string publicName = expeditionData.Descriptive.PublicName;
			DateTime now = DateTime.Now;
			filename = string.Format(ConfigManager.ReplayFileName, shortName, now, publicName);
			string text = ConfigManager.ReplayFolder;
			filename = Utils.RemoveInvalidCharacters(filename, '_', isFullPath: false);
			if (!Directory.Exists(text))
			{
				text = "./";
			}
			string text2;
			if (ConfigManager.SeparateByRundown)
			{
				text2 = Path.Combine(text, Utils.RemoveInvalidCharacters(((GameDataBlockBase<RundownDataBlock>)(object)block).name));
				fullpath = Path.Combine(text2, filename);
			}
			else
			{
				text2 = Utils.RemoveInvalidCharacters(text);
				fullpath = Path.Combine(text2, filename);
			}
			APILogger.Warn("REPLAY LOCATION: " + fullpath);
			try
			{
				Directory.CreateDirectory(text2);
				fs = new FileStream(fullpath, FileMode.Create, FileAccess.Write, FileShare.Read);
			}
			catch (Exception ex)
			{
				APILogger.Error("Failed to create filestream, falling back to 'replay.gtfo': " + ex.Message);
				fs = new FileStream("replay.gtfo", FileMode.Create, FileAccess.Write, FileShare.Read);
			}
			alertedPlayers.Clear();
			alertedPlayers.Add(PlayerManager.GetLocalPlayerAgent().Owner.Lookup);
			pool = new BufferPool();
			byteOffset = 0;
			buffer.Clear();
			SnapshotManager.types.Write(buffer);
			foreach (Type header in SnapshotManager.types.headers)
			{
				unwrittenHeaders.Add(header);
			}
			state.Clear();
			foreach (Type dynamic in SnapshotManager.types.dynamics)
			{
				state.dynamics.Add(dynamic, new DynamicCollection(dynamic, this));
			}
		}

		[HideFromIl2Cpp]
		internal void Trigger(ReplayHeader header)
		{
			if (fs == null)
			{
				throw new ReplaySnapshotNotInitialized();
			}
			Type type = header.GetType();
			if (completedHeader || unwrittenHeaders.Count == 0)
			{
				completedHeader = true;
				throw new ReplayAllHeadersAlreadyWritten("Cannot write header '" + type.FullName + "' as all headers have been written already.");
			}
			unwrittenHeaders.Remove(type);
			ushort value = SnapshotManager.types[type];
			APILogger.Debug($"[Header: {type.FullName}({value})]{((header.Debug != null) ? (": " + header.Debug) : "")}");
			BitHelper.WriteBytes(value, buffer);
			header.Write(buffer);
			if (unwrittenHeaders.Count == 0)
			{
				completedHeader = true;
				OnHeaderComplete();
			}
		}

		[HideFromIl2Cpp]
		private void SendBufferOverNetwork(ByteBuffer buffer)
		{
			if (Plugin.acknowledged.Count > 0)
			{
				ByteBuffer packet = pool.Checkout();
				BitHelper.WriteBytes(14 + buffer.count, packet);
				BitHelper.WriteBytes((ushort)2, packet);
				BitHelper.WriteBytes(byteOffset, packet);
				BitHelper.WriteBytes(4 + buffer.count, packet);
				BitHelper.WriteBytes(buffer.Array, packet);
				Send(packet);
			}
			byteOffset += 4 + buffer.count;
		}

		private void OnHeaderComplete()
		{
			if (fs == null)
			{
				throw new ReplaySnapshotNotInitialized();
			}
			EndOfHeader endOfHeader = new EndOfHeader();
			APILogger.Debug($"[Header: {typeof(EndOfHeader).FullName}({SnapshotManager.types[typeof(EndOfHeader)]})]{((endOfHeader.Debug != null) ? (": " + endOfHeader.Debug) : "")}");
			endOfHeader.Write(buffer);
			APILogger.Debug($"Acknowledged Clients: {Plugin.acknowledged.Count}");
			SendBufferOverNetwork(buffer);
			buffer.Flush(fs);
			buffer.Shrink();
			Replay.OnHeaderCompletion?.Invoke();
		}

		[HideFromIl2Cpp]
		internal void Configure<T>(int tickRate, int max) where T : ReplayDynamic
		{
			Type typeFromHandle = typeof(T);
			if (!state.dynamics.ContainsKey(typeFromHandle))
			{
				throw new ReplayTypeDoesNotExist("Type '" + typeFromHandle.FullName + "' does not exist.");
			}
			state.dynamics[typeFromHandle].max = max;
			state.dynamics[typeFromHandle].tickRate = tickRate;
		}

		[HideFromIl2Cpp]
		internal bool Trigger(ReplayEvent e)
		{
			try
			{
				EventWrapper item = new EventWrapper(Now, e, pool.Checkout());
				state.events.Add(item);
				return true;
			}
			catch (Exception ex)
			{
				APILogger.Error($"Unexpected error occured whilst trying to write Event[{e.GetType()}] at [{Raudy.Now}ms]:\n{ex}\n{ex.StackTrace}");
			}
			return false;
		}

		[HideFromIl2Cpp]
		internal bool Has(ReplayDynamic dynamic)
		{
			Type type = dynamic.GetType();
			if (!state.dynamics.ContainsKey(type))
			{
				throw new ReplayTypeDoesNotExist("Type '" + type.FullName + "' does not exist.");
			}
			return state.dynamics[type].Has(dynamic);
		}

		[HideFromIl2Cpp]
		internal bool Has(Type type, int id)
		{
			if (!state.dynamics.ContainsKey(type))
			{
				throw new ReplayTypeDoesNotExist("Type '" + type.FullName + "' does not exist.");
			}
			return state.dynamics[type].Has(id);
		}

		[HideFromIl2Cpp]
		internal ReplayDynamic Get(Type type, int id)
		{
			if (!state.dynamics.ContainsKey(type))
			{
				throw new ReplayTypeDoesNotExist("Type '" + type.FullName + "' does not exist.");
			}
			return state.dynamics[type].Get(id);
		}

		[HideFromIl2Cpp]
		internal void Clear(Type type)
		{
			if (!state.dynamics.ContainsKey(type))
			{
				throw new ReplayTypeDoesNotExist("Type '" + type.FullName + "' does not exist.");
			}
			foreach (ReplayDynamic item in state.dynamics[type])
			{
				Despawn(item);
			}
		}

		[HideFromIl2Cpp]
		internal void Spawn(ReplayDynamic dynamic, bool errorOnDuplicate = true)
		{
			Type type = dynamic.GetType();
			if (!state.dynamics.ContainsKey(type))
			{
				throw new ReplayTypeDoesNotExist("Type '" + type.FullName + "' does not exist.");
			}
			if (!Trigger(new ReplaySpawn(dynamic)))
			{
				APILogger.Error($"Unable to spawn '{type}' as spawn event failed.");
			}
			else
			{
				state.dynamics[type].Add(dynamic, errorOnDuplicate);
			}
		}

		[HideFromIl2Cpp]
		internal void Despawn(ReplayDynamic dynamic, bool errorOnNotFound = true)
		{
			Type type = dynamic.GetType();
			if (!state.dynamics.ContainsKey(type))
			{
				throw new ReplayTypeDoesNotExist("Type '" + type.FullName + "' does not exist.");
			}
			if (!Trigger(new ReplayDespawn(dynamic)))
			{
				APILogger.Error($"Unable to despawn '{type}' as despawn event failed.");
			}
			else
			{
				state.dynamics[type].Remove(dynamic.id, errorOnNotFound);
			}
		}

		[HideFromIl2Cpp]
		private async Task Send(ByteBuffer packet)
		{
			foreach (EndPoint item in Plugin.acknowledged)
			{
				if (Plugin.server.Connections.Contains(item))
				{
					await Plugin.server.RawSendTo(packet.Array, item);
				}
			}
			pool.Release(packet);
		}

		private void Tick()
		{
			if (pool.InUse > peakInUse)
			{
				peakInUse = pool.InUse;
			}
			if (++bufferShrinkTick > 100)
			{
				bufferShrinkTick = 0;
				pool.Shrink(Mathf.Max(50, peakInUse));
				peakInUse = 0;
			}
			stopwatch.Restart();
			if (fs == null)
			{
				throw new ReplaySnapshotNotInitialized();
			}
			Replay.OnTick?.Invoke();
			long now = Now;
			if (now > uint.MaxValue)
			{
				Dispose();
				throw new ReplayInvalidTimestamp($"ReplayRecorder does not support replays longer than {-1}ms.");
			}
			buffer.Clear();
			bool flag;
			try
			{
				flag = state.Write(now, buffer);
			}
			catch (Exception ex)
			{
				flag = false;
				APILogger.Error($"Unexpected error occured whilst trying to write tick at [{now}ms]:\n{ex}\n{ex.StackTrace}");
			}
			if (flag)
			{
				SendBufferOverNetwork(buffer);
				float num = stopwatch.ElapsedMilliseconds;
				if (writeTask != null)
				{
					writeTask.Wait();
				}
				waitForWrite = (float)stopwatch.ElapsedMilliseconds - num;
				writeTask = buffer.AsyncFlush(fs);
				ByteBuffer byteBuffer = _buffer;
				_buffer = buffer;
				buffer = byteBuffer;
			}
			stopwatch.Stop();
			tickTime = 0.9f * tickTime + 0.100000024f * (float)stopwatch.ElapsedMilliseconds;
		}

		internal void Dispose()
		{
			APILogger.Debug("Ending Replay...");
			if (fs != null)
			{
				fs.Flush();
				fs.Dispose();
				fs = null;
			}
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		private void Update()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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: Invalid comparison between Unknown and I4
			if (fs == null || !completedHeader)
			{
				return;
			}
			DRAMA_State currentStateEnum = DramaManager.CurrentStateEnum;
			float num = ((currentStateEnum - 5 > 3) ? 0.1f : 0.05f);
			if (tickRate != num)
			{
				timer = 0f;
				tickRate = num;
			}
			timer += Time.deltaTime;
			if (!(timer > tickRate))
			{
				return;
			}
			timer = 0f;
			if (Plugin.acknowledged.Count > 0 && PlayerManager.PlayerAgentsInLevel.Count > 1)
			{
				bool flag = true;
				Enumerator<PlayerAgent> enumerator = PlayerManager.PlayerAgentsInLevel.GetEnumerator();
				while (enumerator.MoveNext())
				{
					PlayerAgent current = enumerator.Current;
					if (!alertedPlayers.Contains(current.Owner.Lookup) && current.Owner.IsInGame)
					{
						flag = false;
						break;
					}
				}
				if (!flag)
				{
					enumerator = PlayerManager.PlayerAgentsInLevel.GetEnumerator();
					while (enumerator.MoveNext())
					{
						PlayerAgent current2 = enumerator.Current;
						if (!alertedPlayers.Contains(current2.Owner.Lookup) && current2.Owner.IsInGame)
						{
							alertedPlayers.Add(current2.Owner.Lookup);
						}
					}
					string text = "GTFOReplay Live View is in use. This allows the spectating user to see all item and enemy locations which may be considered cheating.";
					while (text.Length > 50)
					{
						PlayerChatManager.WantToSentTextMessage(PlayerManager.GetLocalPlayerAgent(), text.Substring(0, 50).Trim(), (PlayerAgent)null);
						text = text.Substring(50).Trim();
					}
					PlayerChatManager.WantToSentTextMessage(PlayerManager.GetLocalPlayerAgent(), text, (PlayerAgent)null);
				}
			}
			Tick();
		}
	}
	internal static class SnapshotManager
	{
		internal static SnapshotTypeManager types = new SnapshotTypeManager();

		internal static SnapshotInstance? instance;

		internal static bool Ready
		{
			get
			{
				if ((Object)(object)instance != (Object)null)
				{
					return instance.Ready;
				}
				return false;
			}
		}

		internal static bool Active
		{
			get
			{
				if ((Object)(object)instance != (Object)null)
				{
					return instance.Active;
				}
				return false;
			}
		}

		internal static void OnElevatorStart()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)instance == (Object)null)
			{
				instance = new GameObject().AddComponent<SnapshotInstance>();
				instance.Init();
				return;
			}
			throw new ReplaySnapshotAlreadyInitialized();
		}

		internal static SnapshotInstance GetInstance()
		{
			if ((Object)(object)instance == (Object)null)
			{
				throw new ReplaySnapshotNotInitialized();
			}
			return instance;
		}

		internal static void OnExpeditionEnd()
		{
			if ((Object)(object)instance != (Object)null)
			{
				instance.Dispose();
				instance = null;
				Replay.OnExpeditionEnd?.Invoke();
			}
		}
	}
}
namespace ReplayRecorder.Snapshot.Types
{
	internal class SnapshotTypeManager
	{
		public readonly HashSet<Type> dynamics = new HashSet<Type>();

		public readonly HashSet<Type> events = new HashSet<Type>();

		public readonly HashSet<Type> headers = new HashSet<Type>();

		private Dictionary<string, Type> typenameMap = new Dictionary<string, Type>();

		private Dictionary<Type, ushort> typeMap = new Dictionary<Type, ushort>();

		private Dictionary<Type, string> versionMap = new Dictionary<Type, string>();

		private ushort staticType;

		public ushort this[Type type]
		{
			get
			{
				if (typeMap.ContainsKey(type))
				{
					return typeMap[type];
				}
				throw new ReplayTypeDoesNotExist("Type '" + type.FullName + "' does not exist.");
			}
		}

		public ushort this[string typename]
		{
			get
			{
				if (typenameMap.ContainsKey(typename))
				{
					return typeMap[typenameMap[typename]];
				}
				throw new ReplayTypeDoesNotExist("Type '" + typename + "' does not exist.");
			}
		}

		public bool Contains(Type type)
		{
			return typeMap.ContainsKey(type);
		}

		public void RegisterType(ReplayData data, Type type)
		{
			if (data.Typename == string.Empty)
			{
				throw new ReplayEmptyTypename("Typename cannot be a blank string.");
			}
			if (typenameMap.ContainsKey(data.Typename))
			{
				throw new ReplayDuplicateTypeName("Typename '" + data.Typename + "' already exists.");
			}
			if (typeMap.ContainsKey(type))
			{
				throw new ReplayDuplicateType("Type '" + type.FullName + "' already exists.");
			}
			if (staticType == ushort.MaxValue)
			{
				throw new ReplayTypeOverflow("Could not assign type '" + data.Typename + "' as there are no more indicies that can be assigned.");
			}
			string value;
			if (typeof(ReplayDynamic).IsAssignableFrom(type))
			{
				value = "Dynamic";
				dynamics.Add(type);
			}
			else if (typeof(ReplayEvent).IsAssignableFrom(type))
			{
				value = "Event";
				events.Add(type);
			}
			else
			{
				if (!typeof(ReplayHeader).IsAssignableFrom(type))
				{
					throw new ReplayIncompatibleType("Type '" + type.FullName + "' is not a Dynamic, Event or Header.");
				}
				value = "Header";
				headers.Add(type);
			}
			ushort value2 = staticType++;
			typenameMap.Add(data.Typename, type);
			typeMap.Add(type, value2);
			versionMap.Add(type, data.Version);
			APILogger.Debug($"Registered {value}: '{data.Typename}' => {type.FullName}[{value2}]");
		}

		public void Write(ByteBuffer buffer)
		{
			StringBuilder stringBuilder = new StringBuilder();
			BitHelper.WriteBytes("0.0.1", buffer);
			BitHelper.WriteBytes((ushort)typenameMap.Count, buffer);
			StringBuilder stringBuilder2 = stringBuilder;
			StringBuilder stringBuilder3 = stringBuilder2;
			StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(12, 1, stringBuilder2);
			handler.AppendLiteral("\n\tTypeMap[");
			handler.AppendFormatted(typenameMap.Count);
			handler.AppendLiteral("]:");
			stringBuilder3.AppendLine(ref handler);
			foreach (KeyValuePair<string, Type> item in typenameMap)
			{
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder4 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(10, 4, stringBuilder2);
				handler.AppendLiteral("\t");
				handler.AppendFormatted(typeMap[item.Value]);
				handler.AppendLiteral(" => ");
				handler.AppendFormatted(item.Key);
				handler.AppendLiteral("(");
				handler.AppendFormatted(versionMap[item.Value]);
				handler.AppendLiteral(") [");
				handler.AppendFormatted(item.Value.FullName);
				handler.AppendLiteral("]");
				stringBuilder4.AppendLine(ref handler);
				BitHelper.WriteBytes(typeMap[item.Value], buffer);
				BitHelper.WriteBytes(item.Key, buffer);
				BitHelper.WriteBytes(versionMap[item.Value], buffer);
			}
			APILogger.Debug(stringBuilder.ToString());
		}
	}
}
namespace ReplayRecorder.Snapshot.Exceptions
{
	public class ReplaySnapshotAlreadyInitialized : Exception
	{
		public ReplaySnapshotAlreadyInitialized()
			: base("Snapshot has already been initialized.")
		{
		}
	}
	public class ReplaySnapshotNotInitialized : Exception
	{
		public ReplaySnapshotNotInitialized()
			: base("Snapshot has not been initialized yet.")
		{
		}
	}
	public class ReplayAllHeadersAlreadyWritten : Exception
	{
		public ReplayAllHeadersAlreadyWritten(string message)
			: base(message)
		{
		}
	}
	public class ReplayHeaderAlreadyWritten : Exception
	{
		public ReplayHeaderAlreadyWritten(string message)
			: base(message)
		{
		}
	}
	public class ReplayDynamicDoesNotExist : Exception
	{
		public ReplayDynamicDoesNotExist(string message)
			: base(message)
		{
		}
	}
	public class ReplayDynamicAlreadyExists : Exception
	{
		public ReplayDynamicAlreadyExists(string message)
			: base(message)
		{
		}
	}
	public class ReplayInvalidDeltaTime : Exception
	{
		public ReplayInvalidDeltaTime(string message)
			: base(message)
		{
		}
	}
	public class ReplayInvalidTimestamp : Exception
	{
		public ReplayInvalidTimestamp(string message)
			: base(message)
		{
		}
	}
	public class ReplayEmptyTypename : Exception
	{
		public ReplayEmptyTypename(string message)
			: base(message)
		{
		}
	}
	public class ReplayIncompatibleType : Exception
	{
		public ReplayIncompatibleType(string message)
			: base(message)
		{
		}
	}
	public class ReplayTypeDoesNotExist : Exception
	{
		public ReplayTypeDoesNotExist(string message)
			: base(message)
		{
		}
	}
	public class ReplayDuplicateTypeName : Exception
	{
		public ReplayDuplicateTypeName(string message)
			: base(message)
		{
		}
	}
	public class ReplayDuplicateType : Exception
	{
		public ReplayDuplicateType(string message)
			: base(message)
		{
		}
	}
	public class ReplayTypeOverflow : Exception
	{
		public ReplayTypeOverflow(string message)
			: base(message)
		{
		}
	}
}
namespace ReplayRecorder.BepInEx
{
	public static class Module
	{
		public const string GUID = "randomuserhi.ReplayRecorder";

		public const string Name = "ReplayRecorder";

		public const string Version = "0.0.1";
	}
	public static class ConfigManager
	{
		public static ConfigFile configFile;

		private static ConfigEntry<bool> debug;

		private static ConfigEntry<bool> performanceDebug;

		private static ConfigEntry<bool> debugDynamics;

		private static ConfigEntry<string> replayFolder;

		private static ConfigEntry<string> replayFilename;

		private static ConfigEntry<bool> separateByRundown;

		public static bool Debug
		{
			get
			{
				return debug.Value;
			}
			set
			{
				debug.Value = value;
			}
		}

		public static bool PerformanceDebug
		{
			get
			{
				return performanceDebug.Value;
			}
			set
			{
				performanceDebug.Value = value;
			}
		}

		public static bool DebugDynamics
		{
			get
			{
				return debugDynamics.Value;
			}
			set
			{
				debugDynamics.Value = value;
			}
		}

		public static string ReplayFolder
		{
			get
			{
				return replayFolder.Value;
			}
			set
			{
				replayFolder.Value