using System;
using System.Buffers;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net.WebSockets;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.Threading.Tasks;
using MegabonkTogether.Common.Messages;
using MegabonkTogether.Common.Messages.GameNetworkMessages;
using MegabonkTogether.Common.Messages.WsMessages;
using MegabonkTogether.Common.Models;
using MemoryPack;
using MemoryPack.Formatters;
using MemoryPack.Internal;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("MegabonkTogether.Common")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("5.1.0.0")]
[assembly: AssemblyInformationalVersion("5.1.0+041881b79682a7845c5afc2ebf6887f809808a03")]
[assembly: AssemblyProduct("MegabonkTogether.Common")]
[assembly: AssemblyTitle("MegabonkTogether.Common")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("5.1.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace MegabonkTogether.Common.Models
{
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class BossOrbModel : IMemoryPackable<BossOrbModel>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class BossOrbModelFormatter : MemoryPackFormatter<BossOrbModel>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref BossOrbModel value)
			{
				BossOrbModel.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref BossOrbModel value)
			{
				BossOrbModel.Deserialize(ref reader, ref value);
			}
		}

		public QuantizedVector3 Position = new QuantizedVector3();

		public uint Id { get; set; }

		static BossOrbModel()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<BossOrbModel>())
			{
				MemoryPackFormatterProvider.Register<BossOrbModel>((MemoryPackFormatter<BossOrbModel>)(object)new BossOrbModelFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<BossOrbModel[]>())
			{
				MemoryPackFormatterProvider.Register<BossOrbModel[]>((MemoryPackFormatter<BossOrbModel[]>)(object)new ArrayFormatter<BossOrbModel>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref BossOrbModel? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint id = value.Id;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)2, ref id);
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref value.Position);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref BossOrbModel? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint id = default(uint);
			QuantizedVector3 position;
			if (b == 2)
			{
				if (value != null)
				{
					id = value.Id;
					position = value.Position;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					goto IL_009b;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(BossOrbModel), (byte)2, b);
					return;
				}
				if (value == null)
				{
					id = 0u;
					position = null;
				}
				else
				{
					id = value.Id;
					position = value.Position;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_009b;
				}
			}
			value = new BossOrbModel
			{
				Id = id,
				Position = position
			};
			return;
			IL_009b:
			value.Id = id;
			value.Position = position;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class EnemyModel : IMemoryPackable<EnemyModel>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class EnemyModelFormatter : MemoryPackFormatter<EnemyModel>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref EnemyModel value)
			{
				EnemyModel.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref EnemyModel value)
			{
				EnemyModel.Deserialize(ref reader, ref value);
			}
		}

		public uint Id { get; set; }

		public float Hp { get; set; }

		public QuantizedVector3 Position { get; set; } = new QuantizedVector3();

		public QuantizedRotation Yaw { get; set; } = new QuantizedRotation();

		static EnemyModel()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<EnemyModel>())
			{
				MemoryPackFormatterProvider.Register<EnemyModel>((MemoryPackFormatter<EnemyModel>)(object)new EnemyModelFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<EnemyModel[]>())
			{
				MemoryPackFormatterProvider.Register<EnemyModel[]>((MemoryPackFormatter<EnemyModel[]>)(object)new ArrayFormatter<EnemyModel>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref EnemyModel? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint id = value.Id;
			float hp = value.Hp;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, float>((byte)4, ref id, ref hp);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
			QuantizedRotation yaw = value.Yaw;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedRotation>>(ref writer).WritePackable<QuantizedRotation>(ref yaw);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref EnemyModel? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint id = default(uint);
			float hp = default(float);
			QuantizedVector3 position;
			QuantizedRotation yaw;
			if (b == 4)
			{
				if (value != null)
				{
					id = value.Id;
					hp = value.Hp;
					position = value.Position;
					yaw = value.Yaw;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref hp);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedRotation>(ref yaw);
					goto IL_00fb;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, float>(ref id, ref hp);
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				yaw = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedRotation>();
			}
			else
			{
				if (b > 4)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(EnemyModel), (byte)4, b);
					return;
				}
				if (value == null)
				{
					id = 0u;
					hp = 0f;
					position = null;
					yaw = null;
				}
				else
				{
					id = value.Id;
					hp = value.Hp;
					position = value.Position;
					yaw = value.Yaw;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref hp);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadPackable<QuantizedRotation>(ref yaw);
								_ = 4;
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_00fb;
				}
			}
			value = new EnemyModel
			{
				Id = id,
				Hp = hp,
				Position = position,
				Yaw = yaw
			};
			return;
			IL_00fb:
			value.Id = id;
			value.Hp = hp;
			value.Position = position;
			value.Yaw = yaw;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class InventoryInfo : IMemoryPackable<InventoryInfo>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class InventoryInfoFormatter : MemoryPackFormatter<InventoryInfo>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref InventoryInfo value)
			{
				InventoryInfo.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref InventoryInfo value)
			{
				InventoryInfo.Deserialize(ref reader, ref value);
			}
		}

		public ICollection<WeaponInfo> WeaponInfos { get; set; } = new List<WeaponInfo>();

		public ICollection<TomeInfo> TomeInfos { get; set; } = new List<TomeInfo>();

		static InventoryInfo()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<InventoryInfo>())
			{
				MemoryPackFormatterProvider.Register<InventoryInfo>((MemoryPackFormatter<InventoryInfo>)(object)new InventoryInfoFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<InventoryInfo[]>())
			{
				MemoryPackFormatterProvider.Register<InventoryInfo[]>((MemoryPackFormatter<InventoryInfo[]>)(object)new ArrayFormatter<InventoryInfo>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<ICollection<WeaponInfo>>())
			{
				MemoryPackFormatterProvider.Register<ICollection<WeaponInfo>>((MemoryPackFormatter<ICollection<WeaponInfo>>)(object)new InterfaceCollectionFormatter<WeaponInfo>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<ICollection<TomeInfo>>())
			{
				MemoryPackFormatterProvider.Register<ICollection<TomeInfo>>((MemoryPackFormatter<ICollection<TomeInfo>>)(object)new InterfaceCollectionFormatter<TomeInfo>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref InventoryInfo? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)2);
			ICollection<WeaponInfo> weaponInfos = value.WeaponInfos;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<ICollection<WeaponInfo>>>(ref writer).WriteValue<ICollection<WeaponInfo>>(ref weaponInfos);
			ICollection<TomeInfo> tomeInfos = value.TomeInfos;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<ICollection<TomeInfo>>>(ref writer).WriteValue<ICollection<TomeInfo>>(ref tomeInfos);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref InventoryInfo? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			ICollection<WeaponInfo> weaponInfos;
			ICollection<TomeInfo> tomeInfos;
			if (b == 2)
			{
				if (value != null)
				{
					weaponInfos = value.WeaponInfos;
					tomeInfos = value.TomeInfos;
					((MemoryPackReader)(ref reader)).ReadValue<ICollection<WeaponInfo>>(ref weaponInfos);
					((MemoryPackReader)(ref reader)).ReadValue<ICollection<TomeInfo>>(ref tomeInfos);
					goto IL_009a;
				}
				weaponInfos = ((MemoryPackReader)(ref reader)).ReadValue<ICollection<WeaponInfo>>();
				tomeInfos = ((MemoryPackReader)(ref reader)).ReadValue<ICollection<TomeInfo>>();
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(InventoryInfo), (byte)2, b);
					return;
				}
				if (value == null)
				{
					weaponInfos = null;
					tomeInfos = null;
				}
				else
				{
					weaponInfos = value.WeaponInfos;
					tomeInfos = value.TomeInfos;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadValue<ICollection<WeaponInfo>>(ref weaponInfos);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadValue<ICollection<TomeInfo>>(ref tomeInfos);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_009a;
				}
			}
			value = new InventoryInfo
			{
				WeaponInfos = weaponInfos,
				TomeInfos = tomeInfos
			};
			return;
			IL_009a:
			value.WeaponInfos = weaponInfos;
			value.TomeInfos = tomeInfos;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class WeaponInfo : IMemoryPackable<WeaponInfo>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class WeaponInfoFormatter : MemoryPackFormatter<WeaponInfo>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref WeaponInfo value)
			{
				WeaponInfo.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref WeaponInfo value)
			{
				WeaponInfo.Deserialize(ref reader, ref value);
			}
		}

		public uint EWeapon;

		public uint Level;

		static WeaponInfo()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<WeaponInfo>())
			{
				MemoryPackFormatterProvider.Register<WeaponInfo>((MemoryPackFormatter<WeaponInfo>)(object)new WeaponInfoFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<WeaponInfo[]>())
			{
				MemoryPackFormatterProvider.Register<WeaponInfo[]>((MemoryPackFormatter<WeaponInfo[]>)(object)new ArrayFormatter<WeaponInfo>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref WeaponInfo? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
			}
			else
			{
				Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref value.EWeapon, ref value.Level);
			}
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref WeaponInfo? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint eWeapon = default(uint);
			uint level = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					eWeapon = value.EWeapon;
					level = value.Level;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref eWeapon);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref level);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref eWeapon, ref level);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(WeaponInfo), (byte)2, b);
					return;
				}
				if (value == null)
				{
					eWeapon = 0u;
					level = 0u;
				}
				else
				{
					eWeapon = value.EWeapon;
					level = value.Level;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref eWeapon);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref level);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new WeaponInfo
			{
				EWeapon = eWeapon,
				Level = level
			};
			return;
			IL_0096:
			value.EWeapon = eWeapon;
			value.Level = level;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class TomeInfo : IMemoryPackable<TomeInfo>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class TomeInfoFormatter : MemoryPackFormatter<TomeInfo>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TomeInfo value)
			{
				TomeInfo.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref TomeInfo value)
			{
				TomeInfo.Deserialize(ref reader, ref value);
			}
		}

		public uint ETome;

		public uint Level;

		static TomeInfo()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<TomeInfo>())
			{
				MemoryPackFormatterProvider.Register<TomeInfo>((MemoryPackFormatter<TomeInfo>)(object)new TomeInfoFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<TomeInfo[]>())
			{
				MemoryPackFormatterProvider.Register<TomeInfo[]>((MemoryPackFormatter<TomeInfo[]>)(object)new ArrayFormatter<TomeInfo>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TomeInfo? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
			}
			else
			{
				Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref value.ETome, ref value.Level);
			}
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref TomeInfo? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint eTome = default(uint);
			uint level = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					eTome = value.ETome;
					level = value.Level;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref eTome);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref level);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref eTome, ref level);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(TomeInfo), (byte)2, b);
					return;
				}
				if (value == null)
				{
					eTome = 0u;
					level = 0u;
				}
				else
				{
					eTome = value.ETome;
					level = value.Level;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref eTome);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref level);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new TomeInfo
			{
				ETome = eTome,
				Level = level
			};
			return;
			IL_0096:
			value.ETome = eTome;
			value.Level = level;
		}
	}
	public enum NetworkModeType
	{
		Random,
		Friendlies
	}
	public enum Role
	{
		Host,
		Client
	}
	public class NetworkMode
	{
		public NetworkModeType Mode { get; set; }

		public Role Role { get; set; }

		public string RoomCode { get; set; } = "";

		public bool? EnabledSharedExperience { get; set; }
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class PickupModel : IMemoryPackable<PickupModel>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class PickupModelFormatter : MemoryPackFormatter<PickupModel>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PickupModel value)
			{
				PickupModel.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref PickupModel value)
			{
				PickupModel.Deserialize(ref reader, ref value);
			}
		}

		public Vector3 Position = Vector3.Zero;

		public uint Id { get; set; }

		static PickupModel()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<PickupModel>())
			{
				MemoryPackFormatterProvider.Register<PickupModel>((MemoryPackFormatter<PickupModel>)(object)new PickupModelFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<PickupModel[]>())
			{
				MemoryPackFormatterProvider.Register<PickupModel[]>((MemoryPackFormatter<PickupModel[]>)(object)new ArrayFormatter<PickupModel>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PickupModel? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint id = value.Id;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, Vector3>((byte)2, ref id, ref value.Position);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref PickupModel? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint id = default(uint);
			Vector3 position = default(Vector3);
			if (b == 2)
			{
				if (value != null)
				{
					id = value.Id;
					position = value.Position;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
					goto IL_009c;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, Vector3>(ref id, ref position);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(PickupModel), (byte)2, b);
					return;
				}
				if (value == null)
				{
					id = 0u;
					position = default(Vector3);
				}
				else
				{
					id = value.Id;
					position = value.Position;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_009c;
				}
			}
			value = new PickupModel
			{
				Id = id,
				Position = position
			};
			return;
			IL_009c:
			value.Id = id;
			value.Position = position;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class Player : IMemoryPackable<Player>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class PlayerFormatter : MemoryPackFormatter<Player>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref Player value)
			{
				Player.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref Player value)
			{
				Player.Deserialize(ref reader, ref value);
			}
		}

		public uint ConnectionId;

		public bool IsHost;

		public uint Character;

		public string Skin = "";

		public bool IsReady;

		public string Name = "Player";

		public QuantizedVector3 Position = new QuantizedVector3();

		public uint Hp = 100u;

		public uint MaxHp = 100u;

		public uint Shield;

		public uint MaxShield;

		public AnimatorState AnimatorState { get; set; } = new AnimatorState();

		public MovementState MovementState { get; set; } = new MovementState();

		public InventoryInfo Inventory { get; set; } = new InventoryInfo();

		static Player()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<Player>())
			{
				MemoryPackFormatterProvider.Register<Player>((MemoryPackFormatter<Player>)(object)new PlayerFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<Player[]>())
			{
				MemoryPackFormatterProvider.Register<Player[]>((MemoryPackFormatter<Player[]>)(object)new ArrayFormatter<Player>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref Player? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, bool, uint>((byte)14, ref value.ConnectionId, ref value.IsHost, ref value.Character);
			writer.WriteString(value.Skin);
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<bool>>(ref writer).WriteUnmanaged<bool>(ref value.IsReady);
			writer.WriteString(value.Name);
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref value.Position);
			AnimatorState animatorState = value.AnimatorState;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<AnimatorState>>(ref writer).WritePackable<AnimatorState>(ref animatorState);
			MovementState movementState = value.MovementState;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<MovementState>>(ref writer).WritePackable<MovementState>(ref movementState);
			InventoryInfo inventory = value.Inventory;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<InventoryInfo>>(ref writer).WritePackable<InventoryInfo>(ref inventory);
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint, uint, uint, uint>(ref value.Hp, ref value.MaxHp, ref value.Shield, ref value.MaxShield);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref Player? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint connectionId = default(uint);
			bool isHost = default(bool);
			uint character = default(uint);
			bool isReady = default(bool);
			QuantizedVector3 position;
			AnimatorState animatorState;
			MovementState movementState;
			InventoryInfo inventory;
			uint hp = default(uint);
			uint maxHp = default(uint);
			uint shield = default(uint);
			uint maxShield = default(uint);
			string skin;
			string name;
			if (b == 14)
			{
				if (value != null)
				{
					connectionId = value.ConnectionId;
					isHost = value.IsHost;
					character = value.Character;
					skin = value.Skin;
					isReady = value.IsReady;
					name = value.Name;
					position = value.Position;
					animatorState = value.AnimatorState;
					movementState = value.MovementState;
					inventory = value.Inventory;
					hp = value.Hp;
					maxHp = value.MaxHp;
					shield = value.Shield;
					maxShield = value.MaxShield;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isHost);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref character);
					skin = ((MemoryPackReader)(ref reader)).ReadString();
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isReady);
					name = ((MemoryPackReader)(ref reader)).ReadString();
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadPackable<AnimatorState>(ref animatorState);
					((MemoryPackReader)(ref reader)).ReadPackable<MovementState>(ref movementState);
					((MemoryPackReader)(ref reader)).ReadPackable<InventoryInfo>(ref inventory);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref hp);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref maxHp);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref shield);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref maxShield);
					goto IL_02e2;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, bool, uint>(ref connectionId, ref isHost, ref character);
				skin = ((MemoryPackReader)(ref reader)).ReadString();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isReady);
				name = ((MemoryPackReader)(ref reader)).ReadString();
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				animatorState = ((MemoryPackReader)(ref reader)).ReadPackable<AnimatorState>();
				movementState = ((MemoryPackReader)(ref reader)).ReadPackable<MovementState>();
				inventory = ((MemoryPackReader)(ref reader)).ReadPackable<InventoryInfo>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint, uint, uint>(ref hp, ref maxHp, ref shield, ref maxShield);
			}
			else
			{
				if (b > 14)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(Player), (byte)14, b);
					return;
				}
				if (value == null)
				{
					connectionId = 0u;
					isHost = false;
					character = 0u;
					skin = null;
					isReady = false;
					name = null;
					position = null;
					animatorState = null;
					movementState = null;
					inventory = null;
					hp = 0u;
					maxHp = 0u;
					shield = 0u;
					maxShield = 0u;
				}
				else
				{
					connectionId = value.ConnectionId;
					isHost = value.IsHost;
					character = value.Character;
					skin = value.Skin;
					isReady = value.IsReady;
					name = value.Name;
					position = value.Position;
					animatorState = value.AnimatorState;
					movementState = value.MovementState;
					inventory = value.Inventory;
					hp = value.Hp;
					maxHp = value.MaxHp;
					shield = value.Shield;
					maxShield = value.MaxShield;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isHost);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref character);
							if (b != 3)
							{
								skin = ((MemoryPackReader)(ref reader)).ReadString();
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isReady);
									if (b != 5)
									{
										name = ((MemoryPackReader)(ref reader)).ReadString();
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
											if (b != 7)
											{
												((MemoryPackReader)(ref reader)).ReadPackable<AnimatorState>(ref animatorState);
												if (b != 8)
												{
													((MemoryPackReader)(ref reader)).ReadPackable<MovementState>(ref movementState);
													if (b != 9)
													{
														((MemoryPackReader)(ref reader)).ReadPackable<InventoryInfo>(ref inventory);
														if (b != 10)
														{
															((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref hp);
															if (b != 11)
															{
																((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref maxHp);
																if (b != 12)
																{
																	((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref shield);
																	if (b != 13)
																	{
																		((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref maxShield);
																		_ = 14;
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_02e2;
				}
			}
			value = new Player
			{
				ConnectionId = connectionId,
				IsHost = isHost,
				Character = character,
				Skin = skin,
				IsReady = isReady,
				Name = name,
				Position = position,
				AnimatorState = animatorState,
				MovementState = movementState,
				Inventory = inventory,
				Hp = hp,
				MaxHp = maxHp,
				Shield = shield,
				MaxShield = maxShield
			};
			return;
			IL_02e2:
			value.ConnectionId = connectionId;
			value.IsHost = isHost;
			value.Character = character;
			value.Skin = skin;
			value.IsReady = isReady;
			value.Name = name;
			value.Position = position;
			value.AnimatorState = animatorState;
			value.MovementState = movementState;
			value.Inventory = inventory;
			value.Hp = hp;
			value.MaxHp = maxHp;
			value.Shield = shield;
			value.MaxShield = maxShield;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class Projectile : IMemoryPackable<Projectile>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class ProjectileFormatter : MemoryPackFormatter<Projectile>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref Projectile value)
			{
				Projectile.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref Projectile value)
			{
				Projectile.Deserialize(ref reader, ref value);
			}
		}

		public QuantizedVector3 Position = new QuantizedVector3();

		public QuantizedVector3 FordwardVector = new QuantizedVector3();

		public uint Id { get; set; }

		static Projectile()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<Projectile>())
			{
				MemoryPackFormatterProvider.Register<Projectile>((MemoryPackFormatter<Projectile>)(object)new ProjectileFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<Projectile[]>())
			{
				MemoryPackFormatterProvider.Register<Projectile[]>((MemoryPackFormatter<Projectile[]>)(object)new ArrayFormatter<Projectile>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref Projectile? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint id = value.Id;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)3, ref id);
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref value.Position);
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref value.FordwardVector);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref Projectile? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint id = default(uint);
			QuantizedVector3 position;
			QuantizedVector3 fordwardVector;
			if (b == 3)
			{
				if (value != null)
				{
					id = value.Id;
					position = value.Position;
					fordwardVector = value.FordwardVector;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref fordwardVector);
					goto IL_00c8;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				fordwardVector = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(Projectile), (byte)3, b);
					return;
				}
				if (value == null)
				{
					id = 0u;
					position = null;
					fordwardVector = null;
				}
				else
				{
					id = value.Id;
					position = value.Position;
					fordwardVector = value.FordwardVector;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref fordwardVector);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00c8;
				}
			}
			value = new Projectile
			{
				Id = id,
				Position = position,
				FordwardVector = fordwardVector
			};
			return;
			IL_00c8:
			value.Id = id;
			value.Position = position;
			value.FordwardVector = fordwardVector;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class QuantizedRotation : IMemoryPackable<QuantizedRotation>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class QuantizedRotationFormatter : MemoryPackFormatter<QuantizedRotation>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref QuantizedRotation value)
			{
				QuantizedRotation.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref QuantizedRotation value)
			{
				QuantizedRotation.Deserialize(ref reader, ref value);
			}
		}

		public ushort QuantizedYaw { get; set; }

		static QuantizedRotation()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<QuantizedRotation>())
			{
				MemoryPackFormatterProvider.Register<QuantizedRotation>((MemoryPackFormatter<QuantizedRotation>)(object)new QuantizedRotationFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<QuantizedRotation[]>())
			{
				MemoryPackFormatterProvider.Register<QuantizedRotation[]>((MemoryPackFormatter<QuantizedRotation[]>)(object)new ArrayFormatter<QuantizedRotation>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref QuantizedRotation? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			ushort quantizedYaw = value.QuantizedYaw;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<ushort>>(ref writer).WriteUnmanagedWithObjectHeader<ushort>((byte)1, ref quantizedYaw);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref QuantizedRotation? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			ushort quantizedYaw = default(ushort);
			if (b == 1)
			{
				if (value != null)
				{
					quantizedYaw = value.QuantizedYaw;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<ushort>(ref quantizedYaw);
					goto IL_006b;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<ushort>(ref quantizedYaw);
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(QuantizedRotation), (byte)1, b);
					return;
				}
				quantizedYaw = (ushort)((value != null) ? value.QuantizedYaw : 0);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<ushort>(ref quantizedYaw);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006b;
				}
			}
			value = new QuantizedRotation
			{
				QuantizedYaw = quantizedYaw
			};
			return;
			IL_006b:
			value.QuantizedYaw = quantizedYaw;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class QuantizedVector2 : IMemoryPackable<QuantizedVector2>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class QuantizedVector2Formatter : MemoryPackFormatter<QuantizedVector2>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref QuantizedVector2 value)
			{
				QuantizedVector2.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref QuantizedVector2 value)
			{
				QuantizedVector2.Deserialize(ref reader, ref value);
			}
		}

		public short QuantizedX { get; set; }

		public short QuantizedY { get; set; }

		static QuantizedVector2()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<QuantizedVector2>())
			{
				MemoryPackFormatterProvider.Register<QuantizedVector2>((MemoryPackFormatter<QuantizedVector2>)(object)new QuantizedVector2Formatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<QuantizedVector2[]>())
			{
				MemoryPackFormatterProvider.Register<QuantizedVector2[]>((MemoryPackFormatter<QuantizedVector2[]>)(object)new ArrayFormatter<QuantizedVector2>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref QuantizedVector2? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			short quantizedX = value.QuantizedX;
			short quantizedY = value.QuantizedY;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<short>>(ref writer).WriteUnmanagedWithObjectHeader<short, short>((byte)2, ref quantizedX, ref quantizedY);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref QuantizedVector2? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			short quantizedX = default(short);
			short quantizedY = default(short);
			if (b == 2)
			{
				if (value != null)
				{
					quantizedX = value.QuantizedX;
					quantizedY = value.QuantizedY;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedX);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedY);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<short, short>(ref quantizedX, ref quantizedY);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(QuantizedVector2), (byte)2, b);
					return;
				}
				if (value == null)
				{
					quantizedX = 0;
					quantizedY = 0;
				}
				else
				{
					quantizedX = value.QuantizedX;
					quantizedY = value.QuantizedY;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedX);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedY);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new QuantizedVector2
			{
				QuantizedX = quantizedX,
				QuantizedY = quantizedY
			};
			return;
			IL_0096:
			value.QuantizedX = quantizedX;
			value.QuantizedY = quantizedY;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class QuantizedVector3 : IMemoryPackable<QuantizedVector3>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class QuantizedVector3Formatter : MemoryPackFormatter<QuantizedVector3>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref QuantizedVector3 value)
			{
				QuantizedVector3.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref QuantizedVector3 value)
			{
				QuantizedVector3.Deserialize(ref reader, ref value);
			}
		}

		public short QuantizedX { get; set; }

		public short QuantizedY { get; set; }

		public short QuantizedZ { get; set; }

		static QuantizedVector3()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<QuantizedVector3>())
			{
				MemoryPackFormatterProvider.Register<QuantizedVector3>((MemoryPackFormatter<QuantizedVector3>)(object)new QuantizedVector3Formatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<QuantizedVector3[]>())
			{
				MemoryPackFormatterProvider.Register<QuantizedVector3[]>((MemoryPackFormatter<QuantizedVector3[]>)(object)new ArrayFormatter<QuantizedVector3>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref QuantizedVector3? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			short quantizedX = value.QuantizedX;
			short quantizedY = value.QuantizedY;
			short quantizedZ = value.QuantizedZ;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<short>>(ref writer).WriteUnmanagedWithObjectHeader<short, short, short>((byte)3, ref quantizedX, ref quantizedY, ref quantizedZ);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref QuantizedVector3? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			short quantizedX = default(short);
			short quantizedY = default(short);
			short quantizedZ = default(short);
			if (b == 3)
			{
				if (value != null)
				{
					quantizedX = value.QuantizedX;
					quantizedY = value.QuantizedY;
					quantizedZ = value.QuantizedZ;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedX);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedY);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedZ);
					goto IL_00be;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<short, short, short>(ref quantizedX, ref quantizedY, ref quantizedZ);
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(QuantizedVector3), (byte)3, b);
					return;
				}
				if (value == null)
				{
					quantizedX = 0;
					quantizedY = 0;
					quantizedZ = 0;
				}
				else
				{
					quantizedX = value.QuantizedX;
					quantizedY = value.QuantizedY;
					quantizedZ = value.QuantizedZ;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedX);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedY);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedZ);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00be;
				}
			}
			value = new QuantizedVector3
			{
				QuantizedX = quantizedX,
				QuantizedY = quantizedY,
				QuantizedZ = quantizedZ
			};
			return;
			IL_00be:
			value.QuantizedX = quantizedX;
			value.QuantizedY = quantizedY;
			value.QuantizedZ = quantizedZ;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class QuantizedVector4 : IMemoryPackable<QuantizedVector4>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class QuantizedVector4Formatter : MemoryPackFormatter<QuantizedVector4>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref QuantizedVector4 value)
			{
				QuantizedVector4.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref QuantizedVector4 value)
			{
				QuantizedVector4.Deserialize(ref reader, ref value);
			}
		}

		public short QuantizedX { get; set; }

		public short QuantizedY { get; set; }

		public short QuantizedZ { get; set; }

		public short QuantizedW { get; set; }

		static QuantizedVector4()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<QuantizedVector4>())
			{
				MemoryPackFormatterProvider.Register<QuantizedVector4>((MemoryPackFormatter<QuantizedVector4>)(object)new QuantizedVector4Formatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<QuantizedVector4[]>())
			{
				MemoryPackFormatterProvider.Register<QuantizedVector4[]>((MemoryPackFormatter<QuantizedVector4[]>)(object)new ArrayFormatter<QuantizedVector4>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref QuantizedVector4? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			short quantizedX = value.QuantizedX;
			short quantizedY = value.QuantizedY;
			short quantizedZ = value.QuantizedZ;
			short quantizedW = value.QuantizedW;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<short>>(ref writer).WriteUnmanagedWithObjectHeader<short, short, short, short>((byte)4, ref quantizedX, ref quantizedY, ref quantizedZ, ref quantizedW);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref QuantizedVector4? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			short quantizedX = default(short);
			short quantizedY = default(short);
			short quantizedZ = default(short);
			short quantizedW = default(short);
			if (b == 4)
			{
				if (value != null)
				{
					quantizedX = value.QuantizedX;
					quantizedY = value.QuantizedY;
					quantizedZ = value.QuantizedZ;
					quantizedW = value.QuantizedW;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedX);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedY);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedZ);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedW);
					goto IL_00e9;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<short, short, short, short>(ref quantizedX, ref quantizedY, ref quantizedZ, ref quantizedW);
			}
			else
			{
				if (b > 4)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(QuantizedVector4), (byte)4, b);
					return;
				}
				if (value == null)
				{
					quantizedX = 0;
					quantizedY = 0;
					quantizedZ = 0;
					quantizedW = 0;
				}
				else
				{
					quantizedX = value.QuantizedX;
					quantizedY = value.QuantizedY;
					quantizedZ = value.QuantizedZ;
					quantizedW = value.QuantizedW;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedX);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedY);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedZ);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<short>(ref quantizedW);
								_ = 4;
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_00e9;
				}
			}
			value = new QuantizedVector4
			{
				QuantizedX = quantizedX,
				QuantizedY = quantizedY,
				QuantizedZ = quantizedZ,
				QuantizedW = quantizedW
			};
			return;
			IL_00e9:
			value.QuantizedX = quantizedX;
			value.QuantizedY = quantizedY;
			value.QuantizedZ = quantizedZ;
			value.QuantizedW = quantizedW;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class TumbleWeedModel : IMemoryPackable<TumbleWeedModel>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class TumbleWeedModelFormatter : MemoryPackFormatter<TumbleWeedModel>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TumbleWeedModel value)
			{
				TumbleWeedModel.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref TumbleWeedModel value)
			{
				TumbleWeedModel.Deserialize(ref reader, ref value);
			}
		}

		public uint NetplayId { get; set; }

		public QuantizedVector3 Position { get; set; }

		static TumbleWeedModel()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<TumbleWeedModel>())
			{
				MemoryPackFormatterProvider.Register<TumbleWeedModel>((MemoryPackFormatter<TumbleWeedModel>)(object)new TumbleWeedModelFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<TumbleWeedModel[]>())
			{
				MemoryPackFormatterProvider.Register<TumbleWeedModel[]>((MemoryPackFormatter<TumbleWeedModel[]>)(object)new ArrayFormatter<TumbleWeedModel>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TumbleWeedModel? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint netplayId = value.NetplayId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)2, ref netplayId);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref TumbleWeedModel? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint netplayId = default(uint);
			QuantizedVector3 position;
			if (b == 2)
			{
				if (value != null)
				{
					netplayId = value.NetplayId;
					position = value.Position;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					goto IL_009b;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(TumbleWeedModel), (byte)2, b);
					return;
				}
				if (value == null)
				{
					netplayId = 0u;
					position = null;
				}
				else
				{
					netplayId = value.NetplayId;
					position = value.Position;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_009b;
				}
			}
			value = new TumbleWeedModel
			{
				NetplayId = netplayId,
				Position = position
			};
			return;
			IL_009b:
			value.NetplayId = netplayId;
			value.Position = position;
		}
	}
}
namespace MegabonkTogether.Common.Messages
{
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class ChestOpened : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<ChestOpened>
	{
		[Preserve]
		private sealed class ChestOpenedFormatter : MemoryPackFormatter<ChestOpened>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ChestOpened value)
			{
				ChestOpened.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref ChestOpened value)
			{
				ChestOpened.Deserialize(ref reader, ref value);
			}
		}

		public uint ChestId { get; set; }

		public uint OwnerId { get; set; }

		static ChestOpened()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<ChestOpened>())
			{
				MemoryPackFormatterProvider.Register<ChestOpened>((MemoryPackFormatter<ChestOpened>)(object)new ChestOpenedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<ChestOpened[]>())
			{
				MemoryPackFormatterProvider.Register<ChestOpened[]>((MemoryPackFormatter<ChestOpened[]>)(object)new ArrayFormatter<ChestOpened>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ChestOpened? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint chestId = value.ChestId;
			uint ownerId = value.OwnerId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref chestId, ref ownerId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref ChestOpened? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint chestId = default(uint);
			uint ownerId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					chestId = value.ChestId;
					ownerId = value.OwnerId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref chestId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref chestId, ref ownerId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(ChestOpened), (byte)2, b);
					return;
				}
				if (value == null)
				{
					chestId = 0u;
					ownerId = 0u;
				}
				else
				{
					chestId = value.ChestId;
					ownerId = value.OwnerId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref chestId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new ChestOpened
			{
				ChestId = chestId,
				OwnerId = ownerId
			};
			return;
			IL_0096:
			value.ChestId = chestId;
			value.OwnerId = ownerId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class ClientInGameReady : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<ClientInGameReady>
	{
		[Preserve]
		private sealed class ClientInGameReadyFormatter : MemoryPackFormatter<ClientInGameReady>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ClientInGameReady value)
			{
				ClientInGameReady.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref ClientInGameReady value)
			{
				ClientInGameReady.Deserialize(ref reader, ref value);
			}
		}

		public uint ConnectionId { get; set; }

		static ClientInGameReady()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<ClientInGameReady>())
			{
				MemoryPackFormatterProvider.Register<ClientInGameReady>((MemoryPackFormatter<ClientInGameReady>)(object)new ClientInGameReadyFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<ClientInGameReady[]>())
			{
				MemoryPackFormatterProvider.Register<ClientInGameReady[]>((MemoryPackFormatter<ClientInGameReady[]>)(object)new ArrayFormatter<ClientInGameReady>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ClientInGameReady? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint connectionId = value.ConnectionId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)1, ref connectionId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref ClientInGameReady? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint connectionId = default(uint);
			if (b == 1)
			{
				if (value != null)
				{
					connectionId = value.ConnectionId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					goto IL_006b;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(ClientInGameReady), (byte)1, b);
					return;
				}
				connectionId = ((value != null) ? value.ConnectionId : 0u);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006b;
				}
			}
			value = new ClientInGameReady
			{
				ConnectionId = connectionId
			};
			return;
			IL_006b:
			value.ConnectionId = connectionId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class ClientReadyMessage : IWsMessage, IMemoryPackFormatterRegister, IMemoryPackable<ClientReadyMessage>
	{
		[Preserve]
		private sealed class ClientReadyMessageFormatter : MemoryPackFormatter<ClientReadyMessage>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ClientReadyMessage value)
			{
				ClientReadyMessage.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref ClientReadyMessage value)
			{
				ClientReadyMessage.Deserialize(ref reader, ref value);
			}
		}

		static ClientReadyMessage()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<ClientReadyMessage>())
			{
				MemoryPackFormatterProvider.Register<ClientReadyMessage>((MemoryPackFormatter<ClientReadyMessage>)(object)new ClientReadyMessageFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<ClientReadyMessage[]>())
			{
				MemoryPackFormatterProvider.Register<ClientReadyMessage[]>((MemoryPackFormatter<ClientReadyMessage[]>)(object)new ArrayFormatter<ClientReadyMessage>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ClientReadyMessage? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
			}
			else
			{
				writer.WriteObjectHeader((byte)0);
			}
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref ClientReadyMessage? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			if (b == 0)
			{
				if (value != null)
				{
					return;
				}
			}
			else
			{
				if (b > 0)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(ClientReadyMessage), (byte)0, b);
					return;
				}
				_ = value;
				if (value != null)
				{
					return;
				}
			}
			value = new ClientReadyMessage();
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class EnemyDamaged : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<EnemyDamaged>
	{
		[Preserve]
		private sealed class EnemyDamagedFormatter : MemoryPackFormatter<EnemyDamaged>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref EnemyDamaged value)
			{
				EnemyDamaged.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref EnemyDamaged value)
			{
				EnemyDamaged.Deserialize(ref reader, ref value);
			}
		}

		public uint EnemyId { get; set; }

		public float Damage { get; set; }

		public int DamageEffect { get; set; }

		public int DamageBlockedByArmor { get; set; }

		public string DamageSource { get; set; }

		public float DamageProcCoefficient { get; set; }

		public int DamageElement { get; set; }

		public int DamageFlags { get; set; }

		public float DamageKnockback { get; set; }

		public bool DamageIsCrit { get; set; }

		public uint AttackerId { get; set; }

		static EnemyDamaged()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<EnemyDamaged>())
			{
				MemoryPackFormatterProvider.Register<EnemyDamaged>((MemoryPackFormatter<EnemyDamaged>)(object)new EnemyDamagedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<EnemyDamaged[]>())
			{
				MemoryPackFormatterProvider.Register<EnemyDamaged[]>((MemoryPackFormatter<EnemyDamaged[]>)(object)new ArrayFormatter<EnemyDamaged>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref EnemyDamaged? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint enemyId = value.EnemyId;
			float damage = value.Damage;
			int damageEffect = value.DamageEffect;
			int damageBlockedByArmor = value.DamageBlockedByArmor;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, float, int, int>((byte)11, ref enemyId, ref damage, ref damageEffect, ref damageBlockedByArmor);
			writer.WriteString(value.DamageSource);
			float damageProcCoefficient = value.DamageProcCoefficient;
			int damageElement = value.DamageElement;
			int damageFlags = value.DamageFlags;
			float damageKnockback = value.DamageKnockback;
			bool damageIsCrit = value.DamageIsCrit;
			uint attackerId = value.AttackerId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<float>>(ref writer).WriteUnmanaged<float, int, int, float, bool, uint>(ref damageProcCoefficient, ref damageElement, ref damageFlags, ref damageKnockback, ref damageIsCrit, ref attackerId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref EnemyDamaged? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint enemyId = default(uint);
			float damage = default(float);
			int damageEffect = default(int);
			int damageBlockedByArmor = default(int);
			float damageProcCoefficient = default(float);
			int damageElement = default(int);
			int damageFlags = default(int);
			float damageKnockback = default(float);
			bool damageIsCrit = default(bool);
			uint attackerId = default(uint);
			string damageSource;
			if (b == 11)
			{
				if (value != null)
				{
					enemyId = value.EnemyId;
					damage = value.Damage;
					damageEffect = value.DamageEffect;
					damageBlockedByArmor = value.DamageBlockedByArmor;
					damageSource = value.DamageSource;
					damageProcCoefficient = value.DamageProcCoefficient;
					damageElement = value.DamageElement;
					damageFlags = value.DamageFlags;
					damageKnockback = value.DamageKnockback;
					damageIsCrit = value.DamageIsCrit;
					attackerId = value.AttackerId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref enemyId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref damage);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageEffect);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageBlockedByArmor);
					damageSource = ((MemoryPackReader)(ref reader)).ReadString();
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref damageProcCoefficient);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageElement);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageFlags);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref damageKnockback);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref damageIsCrit);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref attackerId);
					goto IL_023d;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, float, int, int>(ref enemyId, ref damage, ref damageEffect, ref damageBlockedByArmor);
				damageSource = ((MemoryPackReader)(ref reader)).ReadString();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<float, int, int, float, bool, uint>(ref damageProcCoefficient, ref damageElement, ref damageFlags, ref damageKnockback, ref damageIsCrit, ref attackerId);
			}
			else
			{
				if (b > 11)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(EnemyDamaged), (byte)11, b);
					return;
				}
				if (value == null)
				{
					enemyId = 0u;
					damage = 0f;
					damageEffect = 0;
					damageBlockedByArmor = 0;
					damageSource = null;
					damageProcCoefficient = 0f;
					damageElement = 0;
					damageFlags = 0;
					damageKnockback = 0f;
					damageIsCrit = false;
					attackerId = 0u;
				}
				else
				{
					enemyId = value.EnemyId;
					damage = value.Damage;
					damageEffect = value.DamageEffect;
					damageBlockedByArmor = value.DamageBlockedByArmor;
					damageSource = value.DamageSource;
					damageProcCoefficient = value.DamageProcCoefficient;
					damageElement = value.DamageElement;
					damageFlags = value.DamageFlags;
					damageKnockback = value.DamageKnockback;
					damageIsCrit = value.DamageIsCrit;
					attackerId = value.AttackerId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref enemyId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref damage);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageEffect);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageBlockedByArmor);
								if (b != 4)
								{
									damageSource = ((MemoryPackReader)(ref reader)).ReadString();
									if (b != 5)
									{
										((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref damageProcCoefficient);
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageElement);
											if (b != 7)
											{
												((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageFlags);
												if (b != 8)
												{
													((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref damageKnockback);
													if (b != 9)
													{
														((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref damageIsCrit);
														if (b != 10)
														{
															((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref attackerId);
															_ = 11;
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_023d;
				}
			}
			value = new EnemyDamaged
			{
				EnemyId = enemyId,
				Damage = damage,
				DamageEffect = damageEffect,
				DamageBlockedByArmor = damageBlockedByArmor,
				DamageSource = damageSource,
				DamageProcCoefficient = damageProcCoefficient,
				DamageElement = damageElement,
				DamageFlags = damageFlags,
				DamageKnockback = damageKnockback,
				DamageIsCrit = damageIsCrit,
				AttackerId = attackerId
			};
			return;
			IL_023d:
			value.EnemyId = enemyId;
			value.Damage = damage;
			value.DamageEffect = damageEffect;
			value.DamageBlockedByArmor = damageBlockedByArmor;
			value.DamageSource = damageSource;
			value.DamageProcCoefficient = damageProcCoefficient;
			value.DamageElement = damageElement;
			value.DamageFlags = damageFlags;
			value.DamageKnockback = damageKnockback;
			value.DamageIsCrit = damageIsCrit;
			value.AttackerId = attackerId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class EnemyDied : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<EnemyDied>
	{
		[Preserve]
		private sealed class EnemyDiedFormatter : MemoryPackFormatter<EnemyDied>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref EnemyDied value)
			{
				EnemyDied.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref EnemyDied value)
			{
				EnemyDied.Deserialize(ref reader, ref value);
			}
		}

		public uint EnemyId { get; set; }

		public uint DiedByOwnerId { get; set; }

		public float DamageProcCoefficient { get; set; }

		public string DamageSource { get; set; }

		static EnemyDied()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<EnemyDied>())
			{
				MemoryPackFormatterProvider.Register<EnemyDied>((MemoryPackFormatter<EnemyDied>)(object)new EnemyDiedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<EnemyDied[]>())
			{
				MemoryPackFormatterProvider.Register<EnemyDied[]>((MemoryPackFormatter<EnemyDied[]>)(object)new ArrayFormatter<EnemyDied>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref EnemyDied? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint enemyId = value.EnemyId;
			uint diedByOwnerId = value.DiedByOwnerId;
			float damageProcCoefficient = value.DamageProcCoefficient;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint, float>((byte)4, ref enemyId, ref diedByOwnerId, ref damageProcCoefficient);
			writer.WriteString(value.DamageSource);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref EnemyDied? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint enemyId = default(uint);
			uint diedByOwnerId = default(uint);
			float damageProcCoefficient = default(float);
			string damageSource;
			if (b == 4)
			{
				if (value != null)
				{
					enemyId = value.EnemyId;
					diedByOwnerId = value.DiedByOwnerId;
					damageProcCoefficient = value.DamageProcCoefficient;
					damageSource = value.DamageSource;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref enemyId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref diedByOwnerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref damageProcCoefficient);
					damageSource = ((MemoryPackReader)(ref reader)).ReadString();
					goto IL_00f6;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint, float>(ref enemyId, ref diedByOwnerId, ref damageProcCoefficient);
				damageSource = ((MemoryPackReader)(ref reader)).ReadString();
			}
			else
			{
				if (b > 4)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(EnemyDied), (byte)4, b);
					return;
				}
				if (value == null)
				{
					enemyId = 0u;
					diedByOwnerId = 0u;
					damageProcCoefficient = 0f;
					damageSource = null;
				}
				else
				{
					enemyId = value.EnemyId;
					diedByOwnerId = value.DiedByOwnerId;
					damageProcCoefficient = value.DamageProcCoefficient;
					damageSource = value.DamageSource;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref enemyId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref diedByOwnerId);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref damageProcCoefficient);
							if (b != 3)
							{
								damageSource = ((MemoryPackReader)(ref reader)).ReadString();
								_ = 4;
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_00f6;
				}
			}
			value = new EnemyDied
			{
				EnemyId = enemyId,
				DiedByOwnerId = diedByOwnerId,
				DamageProcCoefficient = damageProcCoefficient,
				DamageSource = damageSource
			};
			return;
			IL_00f6:
			value.EnemyId = enemyId;
			value.DiedByOwnerId = diedByOwnerId;
			value.DamageProcCoefficient = damageProcCoefficient;
			value.DamageSource = damageSource;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class EnemyExploder : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<EnemyExploder>
	{
		[Preserve]
		private sealed class EnemyExploderFormatter : MemoryPackFormatter<EnemyExploder>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref EnemyExploder value)
			{
				EnemyExploder.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref EnemyExploder value)
			{
				EnemyExploder.Deserialize(ref reader, ref value);
			}
		}

		public uint EnemyId { get; set; }

		public uint SenderId { get; set; }

		static EnemyExploder()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<EnemyExploder>())
			{
				MemoryPackFormatterProvider.Register<EnemyExploder>((MemoryPackFormatter<EnemyExploder>)(object)new EnemyExploderFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<EnemyExploder[]>())
			{
				MemoryPackFormatterProvider.Register<EnemyExploder[]>((MemoryPackFormatter<EnemyExploder[]>)(object)new ArrayFormatter<EnemyExploder>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref EnemyExploder? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint enemyId = value.EnemyId;
			uint senderId = value.SenderId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref enemyId, ref senderId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref EnemyExploder? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint enemyId = default(uint);
			uint senderId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					enemyId = value.EnemyId;
					senderId = value.SenderId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref enemyId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref senderId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref enemyId, ref senderId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(EnemyExploder), (byte)2, b);
					return;
				}
				if (value == null)
				{
					enemyId = 0u;
					senderId = 0u;
				}
				else
				{
					enemyId = value.EnemyId;
					senderId = value.SenderId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref enemyId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref senderId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new EnemyExploder
			{
				EnemyId = enemyId,
				SenderId = senderId
			};
			return;
			IL_0096:
			value.EnemyId = enemyId;
			value.SenderId = senderId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class FinalBossOrbDestroyed : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<FinalBossOrbDestroyed>
	{
		[Preserve]
		private sealed class FinalBossOrbDestroyedFormatter : MemoryPackFormatter<FinalBossOrbDestroyed>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref FinalBossOrbDestroyed value)
			{
				FinalBossOrbDestroyed.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref FinalBossOrbDestroyed value)
			{
				FinalBossOrbDestroyed.Deserialize(ref reader, ref value);
			}
		}

		public uint OrbId { get; set; }

		public uint SenderId { get; set; }

		static FinalBossOrbDestroyed()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<FinalBossOrbDestroyed>())
			{
				MemoryPackFormatterProvider.Register<FinalBossOrbDestroyed>((MemoryPackFormatter<FinalBossOrbDestroyed>)(object)new FinalBossOrbDestroyedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<FinalBossOrbDestroyed[]>())
			{
				MemoryPackFormatterProvider.Register<FinalBossOrbDestroyed[]>((MemoryPackFormatter<FinalBossOrbDestroyed[]>)(object)new ArrayFormatter<FinalBossOrbDestroyed>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref FinalBossOrbDestroyed? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint orbId = value.OrbId;
			uint senderId = value.SenderId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref orbId, ref senderId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref FinalBossOrbDestroyed? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint orbId = default(uint);
			uint senderId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					orbId = value.OrbId;
					senderId = value.SenderId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref orbId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref senderId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref orbId, ref senderId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(FinalBossOrbDestroyed), (byte)2, b);
					return;
				}
				if (value == null)
				{
					orbId = 0u;
					senderId = 0u;
				}
				else
				{
					orbId = value.OrbId;
					senderId = value.SenderId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref orbId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref senderId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new FinalBossOrbDestroyed
			{
				OrbId = orbId,
				SenderId = senderId
			};
			return;
			IL_0096:
			value.OrbId = orbId;
			value.SenderId = senderId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class FinalBossOrbSpawned : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<FinalBossOrbSpawned>
	{
		[Preserve]
		private sealed class FinalBossOrbSpawnedFormatter : MemoryPackFormatter<FinalBossOrbSpawned>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref FinalBossOrbSpawned value)
			{
				FinalBossOrbSpawned.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref FinalBossOrbSpawned value)
			{
				FinalBossOrbSpawned.Deserialize(ref reader, ref value);
			}
		}

		public Orb OrbType { get; set; }

		public uint Target { get; set; }

		public uint OrbId { get; set; }

		static FinalBossOrbSpawned()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<FinalBossOrbSpawned>())
			{
				MemoryPackFormatterProvider.Register<FinalBossOrbSpawned>((MemoryPackFormatter<FinalBossOrbSpawned>)(object)new FinalBossOrbSpawnedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<FinalBossOrbSpawned[]>())
			{
				MemoryPackFormatterProvider.Register<FinalBossOrbSpawned[]>((MemoryPackFormatter<FinalBossOrbSpawned[]>)(object)new ArrayFormatter<FinalBossOrbSpawned>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<Orb>())
			{
				MemoryPackFormatterProvider.Register<Orb>((MemoryPackFormatter<Orb>)(object)new UnmanagedFormatter<Orb>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref FinalBossOrbSpawned? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			Orb orbType = value.OrbType;
			uint target = value.Target;
			uint orbId = value.OrbId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<Orb>>(ref writer).WriteUnmanagedWithObjectHeader<Orb, uint, uint>((byte)3, ref orbType, ref target, ref orbId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref FinalBossOrbSpawned? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			Orb orbType = default(Orb);
			uint target = default(uint);
			uint orbId = default(uint);
			if (b == 3)
			{
				if (value != null)
				{
					orbType = value.OrbType;
					target = value.Target;
					orbId = value.OrbId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Orb>(ref orbType);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref target);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref orbId);
					goto IL_00be;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<Orb, uint, uint>(ref orbType, ref target, ref orbId);
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(FinalBossOrbSpawned), (byte)3, b);
					return;
				}
				if (value == null)
				{
					orbType = Orb.Bleed;
					target = 0u;
					orbId = 0u;
				}
				else
				{
					orbType = value.OrbType;
					target = value.Target;
					orbId = value.OrbId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Orb>(ref orbType);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref target);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref orbId);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00be;
				}
			}
			value = new FinalBossOrbSpawned
			{
				OrbType = orbType,
				Target = target,
				OrbId = orbId
			};
			return;
			IL_00be:
			value.OrbType = orbType;
			value.Target = target;
			value.OrbId = orbId;
		}
	}
	public enum Orb
	{
		Bleed,
		Following,
		Shooty
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	[MemoryPackUnion(0, typeof(LobbyUpdates))]
	[MemoryPackUnion(1, typeof(ClientInGameReady))]
	[MemoryPackUnion(2, typeof(SpawnedObject))]
	[MemoryPackUnion(3, typeof(PlayerUpdate))]
	[MemoryPackUnion(4, typeof(SpawnedEnemy))]
	[MemoryPackUnion(5, typeof(SelectedCharacter))]
	[MemoryPackUnion(6, typeof(EnemyDied))]
	[MemoryPackUnion(7, typeof(SpawnedProjectile))]
	[MemoryPackUnion(8, typeof(ProjectileDone))]
	[MemoryPackUnion(9, typeof(SpawnedPickupOrb))]
	[MemoryPackUnion(10, typeof(SpawnedPickup))]
	[MemoryPackUnion(11, typeof(PickupApplied))]
	[MemoryPackUnion(12, typeof(PickupFollowingPlayer))]
	[MemoryPackUnion(13, typeof(SpawnedChest))]
	[MemoryPackUnion(14, typeof(ChestOpened))]
	[MemoryPackUnion(15, typeof(WeaponAdded))]
	[MemoryPackUnion(16, typeof(InteractableUsed))]
	[MemoryPackUnion(17, typeof(StartingChargingShrine))]
	[MemoryPackUnion(18, typeof(StoppingChargingShrine))]
	[MemoryPackUnion(19, typeof(EnemyExploder))]
	[MemoryPackUnion(20, typeof(EnemyDamaged))]
	[MemoryPackUnion(21, typeof(SpawnedEnemySpecialAttack))]
	[MemoryPackUnion(22, typeof(StartingChargingPylon))]
	[MemoryPackUnion(23, typeof(StoppingChargingPylon))]
	[MemoryPackUnion(24, typeof(FinalBossOrbSpawned))]
	[MemoryPackUnion(25, typeof(FinalBossOrbDestroyed))]
	[MemoryPackUnion(26, typeof(StartedSwarmEvent))]
	[MemoryPackUnion(27, typeof(GameOver))]
	[MemoryPackUnion(28, typeof(PlayerDied))]
	[MemoryPackUnion(29, typeof(RetargetedEnemies))]
	[MemoryPackUnion(30, typeof(Introduced))]
	[MemoryPackUnion(31, typeof(PlayerDisconnected))]
	[MemoryPackUnion(32, typeof(RunStarted))]
	[MemoryPackUnion(33, typeof(SpawnedAxeProjectile))]
	[MemoryPackUnion(34, typeof(SpawnedBlackHoleProjectile))]
	[MemoryPackUnion(35, typeof(SpawnedCringeSwordProjectile))]
	[MemoryPackUnion(36, typeof(SpawnedFireFieldProjectile))]
	[MemoryPackUnion(37, typeof(SpawnedHeroSwordProjectile))]
	[MemoryPackUnion(38, typeof(SpawnedRocketProjectile))]
	[MemoryPackUnion(39, typeof(ProjectilesUpdate))]
	[MemoryPackUnion(40, typeof(TomeAdded))]
	[MemoryPackUnion(41, typeof(LightningStrike))]
	[MemoryPackUnion(42, typeof(TornadoesSpawned))]
	[MemoryPackUnion(43, typeof(StormStarted))]
	[MemoryPackUnion(44, typeof(StormStopped))]
	[MemoryPackUnion(45, typeof(TumbleWeedSpawned))]
	[MemoryPackUnion(46, typeof(TumbleWeedsUpdate))]
	[MemoryPackUnion(47, typeof(TumbleWeedDespawned))]
	[MemoryPackUnion(48, typeof(InteractableCharacterFightEnemySpawned))]
	[MemoryPackUnion(49, typeof(WantToStartFollowingPickup))]
	[MemoryPackUnion(50, typeof(SpawnedShotgunProjectile))]
	[MemoryPackUnion(51, typeof(SpawnedDexecutionerProjectile))]
	[MemoryPackUnion(52, typeof(ItemAdded))]
	[MemoryPackUnion(53, typeof(ItemRemoved))]
	[MemoryPackUnion(54, typeof(WeaponToggled))]
	[MemoryPackUnion(55, typeof(SpawnedObjectInCrypt))]
	[MemoryPackUnion(56, typeof(StartingChargingLamp))]
	[MemoryPackUnion(57, typeof(StoppingChargingLamp))]
	[MemoryPackUnion(58, typeof(TimerStarted))]
	[MemoryPackUnion(59, typeof(HatChanged))]
	[MemoryPackUnion(60, typeof(SpawnedRevolverProjectile))]
	[MemoryPackUnion(61, typeof(SpawnedSniperProjectile))]
	[MemoryPackUnion(62, typeof(SpawnedReviver))]
	[MemoryPackUnion(63, typeof(PlayerRespawned))]
	[MemoryPackUnion(64, typeof(AddXp))]
	[MemoryPackUnion(65, typeof(EncounterClosed))]
	[MemoryPackUnion(66, typeof(CloseEncounter))]
	[MemoryPackUnion(67, typeof(GoldChanged))]
	public interface IGameNetworkMessage : IMemoryPackFormatterRegister
	{
		[Preserve]
		public sealed class IGameNetworkMessageFormatter : MemoryPackFormatter<IGameNetworkMessage>
		{
			private static readonly Dictionary<Type, ushort> __typeToTag = new Dictionary<Type, ushort>(68)
			{
				{
					typeof(LobbyUpdates),
					0
				},
				{
					typeof(ClientInGameReady),
					1
				},
				{
					typeof(SpawnedObject),
					2
				},
				{
					typeof(PlayerUpdate),
					3
				},
				{
					typeof(SpawnedEnemy),
					4
				},
				{
					typeof(SelectedCharacter),
					5
				},
				{
					typeof(EnemyDied),
					6
				},
				{
					typeof(SpawnedProjectile),
					7
				},
				{
					typeof(ProjectileDone),
					8
				},
				{
					typeof(SpawnedPickupOrb),
					9
				},
				{
					typeof(SpawnedPickup),
					10
				},
				{
					typeof(PickupApplied),
					11
				},
				{
					typeof(PickupFollowingPlayer),
					12
				},
				{
					typeof(SpawnedChest),
					13
				},
				{
					typeof(ChestOpened),
					14
				},
				{
					typeof(WeaponAdded),
					15
				},
				{
					typeof(InteractableUsed),
					16
				},
				{
					typeof(StartingChargingShrine),
					17
				},
				{
					typeof(StoppingChargingShrine),
					18
				},
				{
					typeof(EnemyExploder),
					19
				},
				{
					typeof(EnemyDamaged),
					20
				},
				{
					typeof(SpawnedEnemySpecialAttack),
					21
				},
				{
					typeof(StartingChargingPylon),
					22
				},
				{
					typeof(StoppingChargingPylon),
					23
				},
				{
					typeof(FinalBossOrbSpawned),
					24
				},
				{
					typeof(FinalBossOrbDestroyed),
					25
				},
				{
					typeof(StartedSwarmEvent),
					26
				},
				{
					typeof(GameOver),
					27
				},
				{
					typeof(PlayerDied),
					28
				},
				{
					typeof(RetargetedEnemies),
					29
				},
				{
					typeof(Introduced),
					30
				},
				{
					typeof(PlayerDisconnected),
					31
				},
				{
					typeof(RunStarted),
					32
				},
				{
					typeof(SpawnedAxeProjectile),
					33
				},
				{
					typeof(SpawnedBlackHoleProjectile),
					34
				},
				{
					typeof(SpawnedCringeSwordProjectile),
					35
				},
				{
					typeof(SpawnedFireFieldProjectile),
					36
				},
				{
					typeof(SpawnedHeroSwordProjectile),
					37
				},
				{
					typeof(SpawnedRocketProjectile),
					38
				},
				{
					typeof(ProjectilesUpdate),
					39
				},
				{
					typeof(TomeAdded),
					40
				},
				{
					typeof(LightningStrike),
					41
				},
				{
					typeof(TornadoesSpawned),
					42
				},
				{
					typeof(StormStarted),
					43
				},
				{
					typeof(StormStopped),
					44
				},
				{
					typeof(TumbleWeedSpawned),
					45
				},
				{
					typeof(TumbleWeedsUpdate),
					46
				},
				{
					typeof(TumbleWeedDespawned),
					47
				},
				{
					typeof(InteractableCharacterFightEnemySpawned),
					48
				},
				{
					typeof(WantToStartFollowingPickup),
					49
				},
				{
					typeof(SpawnedShotgunProjectile),
					50
				},
				{
					typeof(SpawnedDexecutionerProjectile),
					51
				},
				{
					typeof(ItemAdded),
					52
				},
				{
					typeof(ItemRemoved),
					53
				},
				{
					typeof(WeaponToggled),
					54
				},
				{
					typeof(SpawnedObjectInCrypt),
					55
				},
				{
					typeof(StartingChargingLamp),
					56
				},
				{
					typeof(StoppingChargingLamp),
					57
				},
				{
					typeof(TimerStarted),
					58
				},
				{
					typeof(HatChanged),
					59
				},
				{
					typeof(SpawnedRevolverProjectile),
					60
				},
				{
					typeof(SpawnedSniperProjectile),
					61
				},
				{
					typeof(SpawnedReviver),
					62
				},
				{
					typeof(PlayerRespawned),
					63
				},
				{
					typeof(AddXp),
					64
				},
				{
					typeof(EncounterClosed),
					65
				},
				{
					typeof(CloseEncounter),
					66
				},
				{
					typeof(GoldChanged),
					67
				}
			};

			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref IGameNetworkMessage? value)
			{
				ushort value2;
				if (value == null)
				{
					writer.WriteNullUnionHeader();
				}
				else if (__typeToTag.TryGetValue(value.GetType(), out value2))
				{
					writer.WriteUnionHeader(value2);
					switch (value2)
					{
					case 0:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<LobbyUpdates>>(ref writer).WritePackable<LobbyUpdates>(ref Unsafe.As<IGameNetworkMessage, LobbyUpdates>(ref value));
						break;
					case 1:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<ClientInGameReady>>(ref writer).WritePackable<ClientInGameReady>(ref Unsafe.As<IGameNetworkMessage, ClientInGameReady>(ref value));
						break;
					case 2:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedObject>>(ref writer).WritePackable<SpawnedObject>(ref Unsafe.As<IGameNetworkMessage, SpawnedObject>(ref value));
						break;
					case 3:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<PlayerUpdate>>(ref writer).WritePackable<PlayerUpdate>(ref Unsafe.As<IGameNetworkMessage, PlayerUpdate>(ref value));
						break;
					case 4:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedEnemy>>(ref writer).WritePackable<SpawnedEnemy>(ref Unsafe.As<IGameNetworkMessage, SpawnedEnemy>(ref value));
						break;
					case 5:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SelectedCharacter>>(ref writer).WritePackable<SelectedCharacter>(ref Unsafe.As<IGameNetworkMessage, SelectedCharacter>(ref value));
						break;
					case 6:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<EnemyDied>>(ref writer).WritePackable<EnemyDied>(ref Unsafe.As<IGameNetworkMessage, EnemyDied>(ref value));
						break;
					case 7:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedProjectile>>(ref writer).WritePackable<SpawnedProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedProjectile>(ref value));
						break;
					case 8:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<ProjectileDone>>(ref writer).WritePackable<ProjectileDone>(ref Unsafe.As<IGameNetworkMessage, ProjectileDone>(ref value));
						break;
					case 9:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedPickupOrb>>(ref writer).WritePackable<SpawnedPickupOrb>(ref Unsafe.As<IGameNetworkMessage, SpawnedPickupOrb>(ref value));
						break;
					case 10:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedPickup>>(ref writer).WritePackable<SpawnedPickup>(ref Unsafe.As<IGameNetworkMessage, SpawnedPickup>(ref value));
						break;
					case 11:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<PickupApplied>>(ref writer).WritePackable<PickupApplied>(ref Unsafe.As<IGameNetworkMessage, PickupApplied>(ref value));
						break;
					case 12:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<PickupFollowingPlayer>>(ref writer).WritePackable<PickupFollowingPlayer>(ref Unsafe.As<IGameNetworkMessage, PickupFollowingPlayer>(ref value));
						break;
					case 13:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedChest>>(ref writer).WritePackable<SpawnedChest>(ref Unsafe.As<IGameNetworkMessage, SpawnedChest>(ref value));
						break;
					case 14:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<ChestOpened>>(ref writer).WritePackable<ChestOpened>(ref Unsafe.As<IGameNetworkMessage, ChestOpened>(ref value));
						break;
					case 15:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<WeaponAdded>>(ref writer).WritePackable<WeaponAdded>(ref Unsafe.As<IGameNetworkMessage, WeaponAdded>(ref value));
						break;
					case 16:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<InteractableUsed>>(ref writer).WritePackable<InteractableUsed>(ref Unsafe.As<IGameNetworkMessage, InteractableUsed>(ref value));
						break;
					case 17:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<StartingChargingShrine>>(ref writer).WritePackable<StartingChargingShrine>(ref Unsafe.As<IGameNetworkMessage, StartingChargingShrine>(ref value));
						break;
					case 18:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<StoppingChargingShrine>>(ref writer).WritePackable<StoppingChargingShrine>(ref Unsafe.As<IGameNetworkMessage, StoppingChargingShrine>(ref value));
						break;
					case 19:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<EnemyExploder>>(ref writer).WritePackable<EnemyExploder>(ref Unsafe.As<IGameNetworkMessage, EnemyExploder>(ref value));
						break;
					case 20:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<EnemyDamaged>>(ref writer).WritePackable<EnemyDamaged>(ref Unsafe.As<IGameNetworkMessage, EnemyDamaged>(ref value));
						break;
					case 21:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedEnemySpecialAttack>>(ref writer).WritePackable<SpawnedEnemySpecialAttack>(ref Unsafe.As<IGameNetworkMessage, SpawnedEnemySpecialAttack>(ref value));
						break;
					case 22:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<StartingChargingPylon>>(ref writer).WritePackable<StartingChargingPylon>(ref Unsafe.As<IGameNetworkMessage, StartingChargingPylon>(ref value));
						break;
					case 23:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<StoppingChargingPylon>>(ref writer).WritePackable<StoppingChargingPylon>(ref Unsafe.As<IGameNetworkMessage, StoppingChargingPylon>(ref value));
						break;
					case 24:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<FinalBossOrbSpawned>>(ref writer).WritePackable<FinalBossOrbSpawned>(ref Unsafe.As<IGameNetworkMessage, FinalBossOrbSpawned>(ref value));
						break;
					case 25:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<FinalBossOrbDestroyed>>(ref writer).WritePackable<FinalBossOrbDestroyed>(ref Unsafe.As<IGameNetworkMessage, FinalBossOrbDestroyed>(ref value));
						break;
					case 26:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<StartedSwarmEvent>>(ref writer).WritePackable<StartedSwarmEvent>(ref Unsafe.As<IGameNetworkMessage, StartedSwarmEvent>(ref value));
						break;
					case 27:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<GameOver>>(ref writer).WritePackable<GameOver>(ref Unsafe.As<IGameNetworkMessage, GameOver>(ref value));
						break;
					case 28:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<PlayerDied>>(ref writer).WritePackable<PlayerDied>(ref Unsafe.As<IGameNetworkMessage, PlayerDied>(ref value));
						break;
					case 29:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<RetargetedEnemies>>(ref writer).WritePackable<RetargetedEnemies>(ref Unsafe.As<IGameNetworkMessage, RetargetedEnemies>(ref value));
						break;
					case 30:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<Introduced>>(ref writer).WritePackable<Introduced>(ref Unsafe.As<IGameNetworkMessage, Introduced>(ref value));
						break;
					case 31:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<PlayerDisconnected>>(ref writer).WritePackable<PlayerDisconnected>(ref Unsafe.As<IGameNetworkMessage, PlayerDisconnected>(ref value));
						break;
					case 32:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<RunStarted>>(ref writer).WritePackable<RunStarted>(ref Unsafe.As<IGameNetworkMessage, RunStarted>(ref value));
						break;
					case 33:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedAxeProjectile>>(ref writer).WritePackable<SpawnedAxeProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedAxeProjectile>(ref value));
						break;
					case 34:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedBlackHoleProjectile>>(ref writer).WritePackable<SpawnedBlackHoleProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedBlackHoleProjectile>(ref value));
						break;
					case 35:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedCringeSwordProjectile>>(ref writer).WritePackable<SpawnedCringeSwordProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedCringeSwordProjectile>(ref value));
						break;
					case 36:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedFireFieldProjectile>>(ref writer).WritePackable<SpawnedFireFieldProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedFireFieldProjectile>(ref value));
						break;
					case 37:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedHeroSwordProjectile>>(ref writer).WritePackable<SpawnedHeroSwordProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedHeroSwordProjectile>(ref value));
						break;
					case 38:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedRocketProjectile>>(ref writer).WritePackable<SpawnedRocketProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedRocketProjectile>(ref value));
						break;
					case 39:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<ProjectilesUpdate>>(ref writer).WritePackable<ProjectilesUpdate>(ref Unsafe.As<IGameNetworkMessage, ProjectilesUpdate>(ref value));
						break;
					case 40:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<TomeAdded>>(ref writer).WritePackable<TomeAdded>(ref Unsafe.As<IGameNetworkMessage, TomeAdded>(ref value));
						break;
					case 41:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<LightningStrike>>(ref writer).WritePackable<LightningStrike>(ref Unsafe.As<IGameNetworkMessage, LightningStrike>(ref value));
						break;
					case 42:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<TornadoesSpawned>>(ref writer).WritePackable<TornadoesSpawned>(ref Unsafe.As<IGameNetworkMessage, TornadoesSpawned>(ref value));
						break;
					case 43:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<StormStarted>>(ref writer).WritePackable<StormStarted>(ref Unsafe.As<IGameNetworkMessage, StormStarted>(ref value));
						break;
					case 44:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<StormStopped>>(ref writer).WritePackable<StormStopped>(ref Unsafe.As<IGameNetworkMessage, StormStopped>(ref value));
						break;
					case 45:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<TumbleWeedSpawned>>(ref writer).WritePackable<TumbleWeedSpawned>(ref Unsafe.As<IGameNetworkMessage, TumbleWeedSpawned>(ref value));
						break;
					case 46:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<TumbleWeedsUpdate>>(ref writer).WritePackable<TumbleWeedsUpdate>(ref Unsafe.As<IGameNetworkMessage, TumbleWeedsUpdate>(ref value));
						break;
					case 47:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<TumbleWeedDespawned>>(ref writer).WritePackable<TumbleWeedDespawned>(ref Unsafe.As<IGameNetworkMessage, TumbleWeedDespawned>(ref value));
						break;
					case 48:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<InteractableCharacterFightEnemySpawned>>(ref writer).WritePackable<InteractableCharacterFightEnemySpawned>(ref Unsafe.As<IGameNetworkMessage, InteractableCharacterFightEnemySpawned>(ref value));
						break;
					case 49:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<WantToStartFollowingPickup>>(ref writer).WritePackable<WantToStartFollowingPickup>(ref Unsafe.As<IGameNetworkMessage, WantToStartFollowingPickup>(ref value));
						break;
					case 50:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedShotgunProjectile>>(ref writer).WritePackable<SpawnedShotgunProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedShotgunProjectile>(ref value));
						break;
					case 51:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedDexecutionerProjectile>>(ref writer).WritePackable<SpawnedDexecutionerProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedDexecutionerProjectile>(ref value));
						break;
					case 52:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<ItemAdded>>(ref writer).WritePackable<ItemAdded>(ref Unsafe.As<IGameNetworkMessage, ItemAdded>(ref value));
						break;
					case 53:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<ItemRemoved>>(ref writer).WritePackable<ItemRemoved>(ref Unsafe.As<IGameNetworkMessage, ItemRemoved>(ref value));
						break;
					case 54:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<WeaponToggled>>(ref writer).WritePackable<WeaponToggled>(ref Unsafe.As<IGameNetworkMessage, WeaponToggled>(ref value));
						break;
					case 55:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedObjectInCrypt>>(ref writer).WritePackable<SpawnedObjectInCrypt>(ref Unsafe.As<IGameNetworkMessage, SpawnedObjectInCrypt>(ref value));
						break;
					case 56:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<StartingChargingLamp>>(ref writer).WritePackable<StartingChargingLamp>(ref Unsafe.As<IGameNetworkMessage, StartingChargingLamp>(ref value));
						break;
					case 57:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<StoppingChargingLamp>>(ref writer).WritePackable<StoppingChargingLamp>(ref Unsafe.As<IGameNetworkMessage, StoppingChargingLamp>(ref value));
						break;
					case 58:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<TimerStarted>>(ref writer).WritePackable<TimerStarted>(ref Unsafe.As<IGameNetworkMessage, TimerStarted>(ref value));
						break;
					case 59:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<HatChanged>>(ref writer).WritePackable<HatChanged>(ref Unsafe.As<IGameNetworkMessage, HatChanged>(ref value));
						break;
					case 60:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedRevolverProjectile>>(ref writer).WritePackable<SpawnedRevolverProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedRevolverProjectile>(ref value));
						break;
					case 61:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedSniperProjectile>>(ref writer).WritePackable<SpawnedSniperProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedSniperProjectile>(ref value));
						break;
					case 62:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedReviver>>(ref writer).WritePackable<SpawnedReviver>(ref Unsafe.As<IGameNetworkMessage, SpawnedReviver>(ref value));
						break;
					case 63:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<PlayerRespawned>>(ref writer).WritePackable<PlayerRespawned>(ref Unsafe.As<IGameNetworkMessage, PlayerRespawned>(ref value));
						break;
					case 64:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<AddXp>>(ref writer).WritePackable<AddXp>(ref Unsafe.As<IGameNetworkMessage, AddXp>(ref value));
						break;
					case 65:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<EncounterClosed>>(ref writer).WritePackable<EncounterClosed>(ref Unsafe.As<IGameNetworkMessage, EncounterClosed>(ref value));
						break;
					case 66:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<CloseEncounter>>(ref writer).WritePackable<CloseEncounter>(ref Unsafe.As<IGameNetworkMessage, CloseEncounter>(ref value));
						break;
					case 67:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<GoldChanged>>(ref writer).WritePackable<GoldChanged>(ref Unsafe.As<IGameNetworkMessage, GoldChanged>(ref value));
						break;
					}
				}
				else
				{
					MemoryPackSerializationException.ThrowNotFoundInUnionType(value.GetType(), typeof(IGameNetworkMessage));
				}
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref IGameNetworkMessage? value)
			{
				ushort num = default(ushort);
				if (!((MemoryPackReader)(ref reader)).TryReadUnionHeader(ref num))
				{
					value = null;
					return;
				}
				switch (num)
				{
				case 0:
					if (value is LobbyUpdates)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<LobbyUpdates>(ref Unsafe.As<IGameNetworkMessage, LobbyUpdates>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<LobbyUpdates>();
					}
					break;
				case 1:
					if (value is ClientInGameReady)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<ClientInGameReady>(ref Unsafe.As<IGameNetworkMessage, ClientInGameReady>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<ClientInGameReady>();
					}
					break;
				case 2:
					if (value is SpawnedObject)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedObject>(ref Unsafe.As<IGameNetworkMessage, SpawnedObject>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedObject>();
					}
					break;
				case 3:
					if (value is PlayerUpdate)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<PlayerUpdate>(ref Unsafe.As<IGameNetworkMessage, PlayerUpdate>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<PlayerUpdate>();
					}
					break;
				case 4:
					if (value is SpawnedEnemy)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedEnemy>(ref Unsafe.As<IGameNetworkMessage, SpawnedEnemy>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedEnemy>();
					}
					break;
				case 5:
					if (value is SelectedCharacter)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SelectedCharacter>(ref Unsafe.As<IGameNetworkMessage, SelectedCharacter>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SelectedCharacter>();
					}
					break;
				case 6:
					if (value is EnemyDied)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<EnemyDied>(ref Unsafe.As<IGameNetworkMessage, EnemyDied>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<EnemyDied>();
					}
					break;
				case 7:
					if (value is SpawnedProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedProjectile>();
					}
					break;
				case 8:
					if (value is ProjectileDone)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<ProjectileDone>(ref Unsafe.As<IGameNetworkMessage, ProjectileDone>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<ProjectileDone>();
					}
					break;
				case 9:
					if (value is SpawnedPickupOrb)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedPickupOrb>(ref Unsafe.As<IGameNetworkMessage, SpawnedPickupOrb>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedPickupOrb>();
					}
					break;
				case 10:
					if (value is SpawnedPickup)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedPickup>(ref Unsafe.As<IGameNetworkMessage, SpawnedPickup>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedPickup>();
					}
					break;
				case 11:
					if (value is PickupApplied)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<PickupApplied>(ref Unsafe.As<IGameNetworkMessage, PickupApplied>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<PickupApplied>();
					}
					break;
				case 12:
					if (value is PickupFollowingPlayer)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<PickupFollowingPlayer>(ref Unsafe.As<IGameNetworkMessage, PickupFollowingPlayer>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<PickupFollowingPlayer>();
					}
					break;
				case 13:
					if (value is SpawnedChest)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedChest>(ref Unsafe.As<IGameNetworkMessage, SpawnedChest>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedChest>();
					}
					break;
				case 14:
					if (value is ChestOpened)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<ChestOpened>(ref Unsafe.As<IGameNetworkMessage, ChestOpened>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<ChestOpened>();
					}
					break;
				case 15:
					if (value is WeaponAdded)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<WeaponAdded>(ref Unsafe.As<IGameNetworkMessage, WeaponAdded>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<WeaponAdded>();
					}
					break;
				case 16:
					if (value is InteractableUsed)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<InteractableUsed>(ref Unsafe.As<IGameNetworkMessage, InteractableUsed>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<InteractableUsed>();
					}
					break;
				case 17:
					if (value is StartingChargingShrine)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<StartingChargingShrine>(ref Unsafe.As<IGameNetworkMessage, StartingChargingShrine>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<StartingChargingShrine>();
					}
					break;
				case 18:
					if (value is StoppingChargingShrine)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<StoppingChargingShrine>(ref Unsafe.As<IGameNetworkMessage, StoppingChargingShrine>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<StoppingChargingShrine>();
					}
					break;
				case 19:
					if (value is EnemyExploder)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<EnemyExploder>(ref Unsafe.As<IGameNetworkMessage, EnemyExploder>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<EnemyExploder>();
					}
					break;
				case 20:
					if (value is EnemyDamaged)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<EnemyDamaged>(ref Unsafe.As<IGameNetworkMessage, EnemyDamaged>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<EnemyDamaged>();
					}
					break;
				case 21:
					if (value is SpawnedEnemySpecialAttack)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedEnemySpecialAttack>(ref Unsafe.As<IGameNetworkMessage, SpawnedEnemySpecialAttack>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedEnemySpecialAttack>();
					}
					break;
				case 22:
					if (value is StartingChargingPylon)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<StartingChargingPylon>(ref Unsafe.As<IGameNetworkMessage, StartingChargingPylon>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<StartingChargingPylon>();
					}
					break;
				case 23:
					if (value is StoppingChargingPylon)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<StoppingChargingPylon>(ref Unsafe.As<IGameNetworkMessage, StoppingChargingPylon>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<StoppingChargingPylon>();
					}
					break;
				case 24:
					if (value is FinalBossOrbSpawned)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<FinalBossOrbSpawned>(ref Unsafe.As<IGameNetworkMessage, FinalBossOrbSpawned>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<FinalBossOrbSpawned>();
					}
					break;
				case 25:
					if (value is FinalBossOrbDestroyed)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<FinalBossOrbDestroyed>(ref Unsafe.As<IGameNetworkMessage, FinalBossOrbDestroyed>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<FinalBossOrbDestroyed>();
					}
					break;
				case 26:
					if (value is StartedSwarmEvent)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<StartedSwarmEvent>(ref Unsafe.As<IGameNetworkMessage, StartedSwarmEvent>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<StartedSwarmEvent>();
					}
					break;
				case 27:
					if (value is GameOver)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<GameOver>(ref Unsafe.As<IGameNetworkMessage, GameOver>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<GameOver>();
					}
					break;
				case 28:
					if (value is PlayerDied)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<PlayerDied>(ref Unsafe.As<IGameNetworkMessage, PlayerDied>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<PlayerDied>();
					}
					break;
				case 29:
					if (value is RetargetedEnemies)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<RetargetedEnemies>(ref Unsafe.As<IGameNetworkMessage, RetargetedEnemies>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<RetargetedEnemies>();
					}
					break;
				case 30:
					if (value is Introduced)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<Introduced>(ref Unsafe.As<IGameNetworkMessage, Introduced>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<Introduced>();
					}
					break;
				case 31:
					if (value is PlayerDisconnected)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<PlayerDisconnected>(ref Unsafe.As<IGameNetworkMessage, PlayerDisconnected>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<PlayerDisconnected>();
					}
					break;
				case 32:
					if (value is RunStarted)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<RunStarted>(ref Unsafe.As<IGameNetworkMessage, RunStarted>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<RunStarted>();
					}
					break;
				case 33:
					if (value is SpawnedAxeProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedAxeProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedAxeProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedAxeProjectile>();
					}
					break;
				case 34:
					if (value is SpawnedBlackHoleProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedBlackHoleProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedBlackHoleProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedBlackHoleProjectile>();
					}
					break;
				case 35:
					if (value is SpawnedCringeSwordProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedCringeSwordProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedCringeSwordProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedCringeSwordProjectile>();
					}
					break;
				case 36:
					if (value is SpawnedFireFieldProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedFireFieldProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedFireFieldProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedFireFieldProjectile>();
					}
					break;
				case 37:
					if (value is SpawnedHeroSwordProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedHeroSwordProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedHeroSwordProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedHeroSwordProjectile>();
					}
					break;
				case 38:
					if (value is SpawnedRocketProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedRocketProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedRocketProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedRocketProjectile>();
					}
					break;
				case 39:
					if (value is ProjectilesUpdate)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<ProjectilesUpdate>(ref Unsafe.As<IGameNetworkMessage, ProjectilesUpdate>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<ProjectilesUpdate>();
					}
					break;
				case 40:
					if (value is TomeAdded)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<TomeAdded>(ref Unsafe.As<IGameNetworkMessage, TomeAdded>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<TomeAdded>();
					}
					break;
				case 41:
					if (value is LightningStrike)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<LightningStrike>(ref Unsafe.As<IGameNetworkMessage, LightningStrike>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<LightningStrike>();
					}
					break;
				case 42:
					if (value is TornadoesSpawned)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<TornadoesSpawned>(ref Unsafe.As<IGameNetworkMessage, TornadoesSpawned>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<TornadoesSpawned>();
					}
					break;
				case 43:
					if (value is StormStarted)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<StormStarted>(ref Unsafe.As<IGameNetworkMessage, StormStarted>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<StormStarted>();
					}
					break;
				case 44:
					if (value is StormStopped)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<StormStopped>(ref Unsafe.As<IGameNetworkMessage, StormStopped>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<StormStopped>();
					}
					break;
				case 45:
					if (value is TumbleWeedSpawned)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<TumbleWeedSpawned>(ref Unsafe.As<IGameNetworkMessage, TumbleWeedSpawned>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<TumbleWeedSpawned>();
					}
					break;
				case 46:
					if (value is TumbleWeedsUpdate)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<TumbleWeedsUpdate>(ref Unsafe.As<IGameNetworkMessage, TumbleWeedsUpdate>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<TumbleWeedsUpdate>();
					}
					break;
				case 47:
					if (value is TumbleWeedDespawned)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<TumbleWeedDespawned>(ref Unsafe.As<IGameNetworkMessage, TumbleWeedDespawned>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<TumbleWeedDespawned>();
					}
					break;
				case 48:
					if (value is InteractableCharacterFightEnemySpawned)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<InteractableCharacterFightEnemySpawned>(ref Unsafe.As<IGameNetworkMessage, InteractableCharacterFightEnemySpawned>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<InteractableCharacterFightEnemySpawned>();
					}
					break;
				case 49:
					if (value is WantToStartFollowingPickup)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<WantToStartFollowingPickup>(ref Unsafe.As<IGameNetworkMessage, WantToStartFollowingPickup>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<WantToStartFollowingPickup>();
					}
					break;
				case 50:
					if (value is SpawnedShotgunProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedShotgunProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedShotgunProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedShotgunProjectile>();
					}
					break;
				case 51:
					if (value is SpawnedDexecutionerProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedDexecutionerProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedDexecutionerProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedDexecutionerProjectile>();
					}
					break;
				case 52:
					if (value is ItemAdded)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<ItemAdded>(ref Unsafe.As<IGameNetworkMessage, ItemAdded>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<ItemAdded>();
					}
					break;
				case 53:
					if (value is ItemRemoved)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<ItemRemoved>(ref Unsafe.As<IGameNetworkMessage, ItemRemoved>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<ItemRemoved>();
					}
					break;
				case 54:
					if (value is WeaponToggled)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<WeaponToggled>(ref Unsafe.As<IGameNetworkMessage, WeaponToggled>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<WeaponToggled>();
					}
					break;
				case 55:
					if (value is SpawnedObjectInCrypt)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedObjectInCrypt>(ref Unsafe.As<IGameNetworkMessage, SpawnedObjectInCrypt>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedObjectInCrypt>();
					}
					break;
				case 56:
					if (value is StartingChargingLamp)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<StartingChargingLamp>(ref Unsafe.As<IGameNetworkMessage, StartingChargingLamp>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<StartingChargingLamp>();
					}
					break;
				case 57:
					if (value is StoppingChargingLamp)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<StoppingChargingLamp>(ref Unsafe.As<IGameNetworkMessage, StoppingChargingLamp>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<StoppingChargingLamp>();
					}
					break;
				case 58:
					if (value is TimerStarted)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<TimerStarted>(ref Unsafe.As<IGameNetworkMessage, TimerStarted>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<TimerStarted>();
					}
					break;
				case 59:
					if (value is HatChanged)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<HatChanged>(ref Unsafe.As<IGameNetworkMessage, HatChanged>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<HatChanged>();
					}
					break;
				case 60:
					if (value is SpawnedRevolverProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedRevolverProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedRevolverProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedRevolverProjectile>();
					}
					break;
				case 61:
					if (value is SpawnedSniperProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedSniperProjectile>(ref Unsafe.As<IGameNetworkMessage, SpawnedSniperProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedSniperProjectile>();
					}
					break;
				case 62:
					if (value is SpawnedReviver)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedReviver>(ref Unsafe.As<IGameNetworkMessage, SpawnedReviver>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedReviver>();
					}
					break;
				case 63:
					if (value is PlayerRespawned)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<PlayerRespawned>(ref Unsafe.As<IGameNetworkMessage, PlayerRespawned>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<PlayerRespawned>();
					}
					break;
				case 64:
					if (value is AddXp)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<AddXp>(ref Unsafe.As<IGameNetworkMessage, AddXp>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<AddXp>();
					}
					break;
				case 65:
					if (value is EncounterClosed)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<EncounterClosed>(ref Unsafe.As<IGameNetworkMessage, EncounterClosed>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<EncounterClosed>();
					}
					break;
				case 66:
					if (value is CloseEncounter)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<CloseEncounter>(ref Unsafe.As<IGameNetworkMessage, CloseEncounter>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<CloseEncounter>();
					}
					break;
				case 67:
					if (value is GoldChanged)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<GoldChanged>(ref Unsafe.As<IGameNetworkMessage, GoldChanged>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<GoldChanged>();
					}
					break;
				default:
					MemoryPackSerializationException.ThrowInvalidTag(num, typeof(IGameNetworkMessage));
					break;
				}
			}
		}

		static IGameNetworkMessage()
		{
			RegisterFormatter();
		}

		[Preserve]
		static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<IGameNetworkMessage>())
			{
				MemoryPackFormatterProvider.Register<IGameNetworkMessage>((MemoryPackFormatter<IGameNetworkMessage>)(object)new IGameNetworkMessageFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<IGameNetworkMessage[]>())
			{
				MemoryPackFormatterProvider.Register<IGameNetworkMessage[]>((MemoryPackFormatter<IGameNetworkMessage[]>)(object)new ArrayFormatter<IGameNetworkMessage>());
			}
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class GameOver : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<GameOver>
	{
		[Preserve]
		private sealed class GameOverFormatter : MemoryPackFormatter<GameOver>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref GameOver value)
			{
				GameOver.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref GameOver value)
			{
				GameOver.Deserialize(ref reader, ref value);
			}
		}

		static GameOver()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<GameOver>())
			{
				MemoryPackFormatterProvider.Register<GameOver>((MemoryPackFormatter<GameOver>)(object)new GameOverFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<GameOver[]>())
			{
				MemoryPackFormatterProvider.Register<GameOver[]>((MemoryPackFormatter<GameOver[]>)(object)new ArrayFormatter<GameOver>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref GameOver? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
			}
			else
			{
				writer.WriteObjectHeader((byte)0);
			}
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref GameOver? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			if (b == 0)
			{
				if (value != null)
				{
					return;
				}
			}
			else
			{
				if (b > 0)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(GameOver), (byte)0, b);
					return;
				}
				_ = value;
				if (value != null)
				{
					return;
				}
			}
			value = new GameOver();
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class InteractableUsed : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<InteractableUsed>
	{
		[Preserve]
		private sealed class InteractableUsedFormatter : MemoryPackFormatter<InteractableUsed>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref InteractableUsed value)
			{
				InteractableUsed.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref InteractableUsed value)
			{
				InteractableUsed.Deserialize(ref reader, ref value);
			}
		}

		public uint NetplayId { get; set; }

		public InteractableAction Action { get; set; }

		public bool IsPortal { get; set; }

		public bool IsFinalPortal { get; set; }

		public bool IsCryptKey { get; set; }

		public uint OwnerId { get; set; }

		public bool IsMicrowaveAndHaveItem { get; set; }

		static InteractableUsed()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<InteractableUsed>())
			{
				MemoryPackFormatterProvider.Register<InteractableUsed>((MemoryPackFormatter<InteractableUsed>)(object)new InteractableUsedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<InteractableUsed[]>())
			{
				MemoryPackFormatterProvider.Register<InteractableUsed[]>((MemoryPackFormatter<InteractableUsed[]>)(object)new ArrayFormatter<InteractableUsed>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<InteractableAction>())
			{
				MemoryPackFormatterProvider.Register<InteractableAction>((MemoryPackFormatter<InteractableAction>)(object)new UnmanagedFormatter<InteractableAction>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref InteractableUsed? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint netplayId = value.NetplayId;
			InteractableAction action = value.Action;
			bool isPortal = value.IsPortal;
			bool isFinalPortal = value.IsFinalPortal;
			bool isCryptKey = value.IsCryptKey;
			uint ownerId = value.OwnerId;
			bool isMicrowaveAndHaveItem = value.IsMicrowaveAndHaveItem;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, InteractableAction, bool, bool, bool, uint, bool>((byte)7, ref netplayId, ref action, ref isPortal, ref isFinalPortal, ref isCryptKey, ref ownerId, ref isMicrowaveAndHaveItem);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref InteractableUsed? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint netplayId = default(uint);
			InteractableAction action = default(InteractableAction);
			bool isPortal = default(bool);
			bool isFinalPortal = default(bool);
			bool isCryptKey = default(bool);
			uint ownerId = default(uint);
			bool isMicrowaveAndHaveItem = default(bool);
			if (b == 7)
			{
				if (value != null)
				{
					netplayId = value.NetplayId;
					action = value.Action;
					isPortal = value.IsPortal;
					isFinalPortal = value.IsFinalPortal;
					isCryptKey = value.IsCryptKey;
					ownerId = value.OwnerId;
					isMicrowaveAndHaveItem = value.IsMicrowaveAndHaveItem;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<InteractableAction>(ref action);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isPortal);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isFinalPortal);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isCryptKey);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isMicrowaveAndHaveItem);
					goto IL_0170;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, InteractableAction, bool, bool, bool, uint, bool>(ref netplayId, ref action, ref isPortal, ref isFinalPortal, ref isCryptKey, ref ownerId, ref isMicrowaveAndHaveItem);
			}
			else
			{
				if (b > 7)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(InteractableUsed), (byte)7, b);
					return;
				}
				if (value == null)
				{
					netplayId = 0u;
					action = InteractableAction.Used;
					isPortal = false;
					isFinalPortal = false;
					isCryptKey = false;
					ownerId = 0u;
					isMicrowaveAndHaveItem = false;
				}
				else
				{
					netplayId = value.NetplayId;
					action = value.Action;
					isPortal = value.IsPortal;
					isFinalPortal = value.IsFinalPortal;
					isCryptKey = value.IsCryptKey;
					ownerId = value.OwnerId;
					isMicrowaveAndHaveItem = value.IsMicrowaveAndHaveItem;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<InteractableAction>(ref action);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isPortal);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isFinalPortal);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isCryptKey);
									if (b != 5)
									{
										((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isMicrowaveAndHaveItem);
											_ = 7;
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0170;
				}
			}
			value = new InteractableUsed
			{
				NetplayId = netplayId,
				Action = action,
				IsPortal = isPortal,
				IsFinalPortal = isFinalPortal,
				IsCryptKey = isCryptKey,
				OwnerId = ownerId,
				IsMicrowaveAndHaveItem = isMicrowaveAndHaveItem
			};
			return;
			IL_0170:
			value.NetplayId = netplayId;
			value.Action = action;
			value.IsPortal = isPortal;
			value.IsFinalPortal = isFinalPortal;
			value.IsCryptKey = isCryptKey;
			value.OwnerId = ownerId;
			value.IsMicrowaveAndHaveItem = isMicrowaveAndHaveItem;
		}
	}
	public enum InteractableAction
	{
		Used,
		Interact,
		Destroy
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class Introduced : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<Introduced>
	{
		[Preserve]
		private sealed class IntroducedFormatter : MemoryPackFormatter<Introduced>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref Introduced value)
			{
				Introduced.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref Introduced value)
			{
				Introduced.Deserialize(ref reader, ref value);
			}
		}

		public uint ConnectionId { get; set; }

		public string Name { get; set; } = string.Empty;

		public bool IsHost { get; set; }

		static Introduced()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<Introduced>())
			{
				MemoryPackFormatterProvider.Register<Introduced>((MemoryPackFormatter<Introduced>)(object)new IntroducedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<Introduced[]>())
			{
				MemoryPackFormatterProvider.Register<Introduced[]>((MemoryPackFormatter<Introduced[]>)(object)new ArrayFormatter<Introduced>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref Introduced? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint connectionId = value.ConnectionId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)3, ref connectionId);
			writer.WriteString(value.Name);
			bool isHost = value.IsHost;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<bool>>(ref writer).WriteUnmanaged<bool>(ref isHost);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref Introduced? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint connectionId = default(uint);
			bool isHost = default(bool);
			string name;
			if (b == 3)
			{
				if (value != null)
				{
					connectionId = value.ConnectionId;
					name = value.Name;
					isHost = value.IsHost;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					name = ((MemoryPackReader)(ref reader)).ReadString();
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isHost);
					goto IL_00c7;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
				name = ((MemoryPackReader)(ref reader)).ReadString();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isHost);
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(Introduced), (byte)3, b);
					return;
				}
				if (value == null)
				{
					connectionId = 0u;
					name = null;
					isHost = false;
				}
				else
				{
					connectionId = value.ConnectionId;
					name = value.Name;
					isHost = value.IsHost;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					if (b != 1)
					{
						name = ((MemoryPackReader)(ref reader)).ReadString();
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isHost);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00c7;
				}
			}
			value = new Introduced
			{
				ConnectionId = connectionId,
				Name = name,
				IsHost = isHost
			};
			return;
			IL_00c7:
			value.ConnectionId = connectionId;
			value.Name = name;
			value.IsHost = isHost;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class LightningStrike : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<LightningStrike>
	{
		[Preserve]
		private sealed class LightningStrikeFormatter : MemoryPackFormatter<LightningStrike>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref LightningStrike value)
			{
				LightningStrike.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref LightningStrike value)
			{
				LightningStrike.Deserialize(ref reader, ref value);
			}
		}

		public uint EnemyId { get; set; }

		public int Bounces { get; set; }

		public float Damage { get; set; }

		public int DamageEffect { get; set; }

		public int DamageBlockedByArmor { get; set; }

		public string DamageSource { get; set; } = "";

		public bool DamageIsCrit { get; set; }

		public float DamageProcCoefficient { get; set; }

		public int DamageElement { get; set; }

		public int DamageFlags { get; set; }

		public float DamageKnockback { get; set; }

		public float BounceRange { get; set; }

		public float BounceProcCoefficient { get; set; }

		public uint OwnerId { get; set; }

		static LightningStrike()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<LightningStrike>())
			{
				MemoryPackFormatterProvider.Register<LightningStrike>((MemoryPackFormatter<LightningStrike>)(object)new LightningStrikeFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<LightningStrike[]>())
			{
				MemoryPackFormatterProvider.Register<LightningStrike[]>((MemoryPackFormatter<LightningStrike[]>)(object)new ArrayFormatter<LightningStrike>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref LightningStrike? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint enemyId = value.EnemyId;
			int bounces = value.Bounces;
			float damage = value.Damage;
			int damageEffect = value.DamageEffect;
			int damageBlockedByArmor = value.DamageBlockedByArmor;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, int, float, int, int>((byte)14, ref enemyId, ref bounces, ref damage, ref damageEffect, ref damageBlockedByArmor);
			writer.WriteString(value.DamageSource);
			bool damageIsCrit = value.DamageIsCrit;
			float damageProcCoefficient = value.DamageProcCoefficient;
			int damageElement = value.DamageElement;
			int damageFlags = value.DamageFlags;
			float damageKnockback = value.DamageKnockback;
			float bounceRange = value.BounceRange;
			float bounceProcCoefficient = value.BounceProcCoefficient;
			uint ownerId = value.OwnerId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<bool>>(ref writer).WriteUnmanaged<bool, float, int, int, float, float, float, uint>(ref damageIsCrit, ref damageProcCoefficient, ref damageElement, ref damageFlags, ref damageKnockback, ref bounceRange, ref bounceProcCoefficient, ref ownerId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref LightningStrike? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint enemyId = default(uint);
			int bounces = default(int);
			float damage = default(float);
			int damageEffect = default(int);
			int damageBlockedByArmor = default(int);
			bool damageIsCrit = default(bool);
			float damageProcCoefficient = default(float);
			int damageElement = default(int);
			int damageFlags = default(int);
			float damageKnockback = default(float);
			float bounceRange = default(float);
			float bounceProcCoefficient = default(float);
			uint ownerId = default(uint);
			string damageSource;
			if (b == 14)
			{
				if (value != null)
				{
					enemyId = value.EnemyId;
					bounces = value.Bounces;
					damage = value.Damage;
					damageEffect = value.DamageEffect;
					damageBlockedByArmor = value.DamageBlockedByArmor;
					damageSource = value.DamageSource;
					damageIsCrit = value.DamageIsCrit;
					damageProcCoefficient = value.DamageProcCoefficient;
					damageElement = value.DamageElement;
					damageFlags = value.DamageFlags;
					damageKnockback = value.DamageKnockback;
					bounceRange = value.BounceRange;
					bounceProcCoefficient = value.BounceProcCoefficient;
					ownerId = value.OwnerId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref enemyId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref bounces);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref damage);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageEffect);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageBlockedByArmor);
					damageSource = ((MemoryPackReader)(ref reader)).ReadString();
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref damageIsCrit);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref damageProcCoefficient);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageElement);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageFlags);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref damageKnockback);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref bounceRange);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref bounceProcCoefficient);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					goto IL_02d2;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, int, float, int, int>(ref enemyId, ref bounces, ref damage, ref damageEffect, ref damageBlockedByArmor);
				damageSource = ((MemoryPackReader)(ref reader)).ReadString();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<bool, float, int, int, float, float, float, uint>(ref damageIsCrit, ref damageProcCoefficient, ref damageElement, ref damageFlags, ref damageKnockback, ref bounceRange, ref bounceProcCoefficient, ref ownerId);
			}
			else
			{
				if (b > 14)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(LightningStrike), (byte)14, b);
					return;
				}
				if (value == null)
				{
					enemyId = 0u;
					bounces = 0;
					damage = 0f;
					damageEffect = 0;
					damageBlockedByArmor = 0;
					damageSource = null;
					damageIsCrit = false;
					damageProcCoefficient = 0f;
					damageElement = 0;
					damageFlags = 0;
					damageKnockback = 0f;
					bounceRange = 0f;
					bounceProcCoefficient = 0f;
					ownerId = 0u;
				}
				else
				{
					enemyId = value.EnemyId;
					bounces = value.Bounces;
					damage = value.Damage;
					damageEffect = value.DamageEffect;
					damageBlockedByArmor = value.DamageBlockedByArmor;
					damageSource = value.DamageSource;
					damageIsCrit = value.DamageIsCrit;
					damageProcCoefficient = value.DamageProcCoefficient;
					damageElement = value.DamageElement;
					damageFlags = value.DamageFlags;
					damageKnockback = value.DamageKnockback;
					bounceRange = value.BounceRange;
					bounceProcCoefficient = value.BounceProcCoefficient;
					ownerId = value.OwnerId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref enemyId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref bounces);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref damage);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageEffect);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageBlockedByArmor);
									if (b != 5)
									{
										damageSource = ((MemoryPackReader)(ref reader)).ReadString();
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref damageIsCrit);
											if (b != 7)
											{
												((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref damageProcCoefficient);
												if (b != 8)
												{
													((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageElement);
													if (b != 9)
													{
														((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref damageFlags);
														if (b != 10)
														{
															((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref damageKnockback);
															if (b != 11)
															{
																((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref bounceRange);
																if (b != 12)
																{
																	((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref bounceProcCoefficient);
																	if (b != 13)
																	{
																		((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
																		_ = 14;
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_02d2;
				}
			}
			value = new LightningStrike
			{
				EnemyId = enemyId,
				Bounces = bounces,
				Damage = damage,
				DamageEffect = damageEffect,
				DamageBlockedByArmor = damageBlockedByArmor,
				DamageSource = damageSource,
				DamageIsCrit = damageIsCrit,
				DamageProcCoefficient = damageProcCoefficient,
				DamageElement = damageElement,
				DamageFlags = damageFlags,
				DamageKnockback = damageKnockback,
				BounceRange = bounceRange,
				BounceProcCoefficient = bounceProcCoefficient,
				OwnerId = ownerId
			};
			return;
			IL_02d2:
			value.EnemyId = enemyId;
			value.Bounces = bounces;
			value.Damage = damage;
			value.DamageEffect = damageEffect;
			value.DamageBlockedByArmor = damageBlockedByArmor;
			value.DamageSource = damageSource;
			value.DamageIsCrit = damageIsCrit;
			value.DamageProcCoefficient = damageProcCoefficient;
			value.DamageElement = damageElement;
			value.DamageFlags = damageFlags;
			value.DamageKnockback = damageKnockback;
			value.BounceRange = bounceRange;
			value.BounceProcCoefficient = bounceProcCoefficient;
			value.OwnerId = ownerId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class LobbyUpdates : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<LobbyUpdates>
	{
		[Preserve]
		private sealed class LobbyUpdatesFormatter : MemoryPackFormatter<LobbyUpdates>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref LobbyUpdates value)
			{
				LobbyUpdates.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref LobbyUpdates value)
			{
				LobbyUpdates.Deserialize(ref reader, ref value);
			}
		}

		public IEnumerable<Player> Players = new List<Player>();

		public IEnumerable<EnemyModel> Enemies = new List<EnemyModel>();

		public IEnumerable<BossOrbModel> BossOrbs = new List<BossOrbModel>();

		static LobbyUpdates()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<LobbyUpdates>())
			{
				MemoryPackFormatterProvider.Register<LobbyUpdates>((MemoryPackFormatter<LobbyUpdates>)(object)new LobbyUpdatesFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<LobbyUpdates[]>())
			{
				MemoryPackFormatterProvider.Register<LobbyUpdates[]>((MemoryPackFormatter<LobbyUpdates[]>)(object)new ArrayFormatter<LobbyUpdates>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<IEnumerable<Player>>())
			{
				MemoryPackFormatterProvider.Register<IEnumerable<Player>>((MemoryPackFormatter<IEnumerable<Player>>)(object)new InterfaceEnumerableFormatter<Player>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<IEnumerable<EnemyModel>>())
			{
				MemoryPackFormatterProvider.Register<IEnumerable<EnemyModel>>((MemoryPackFormatter<IEnumerable<EnemyModel>>)(object)new InterfaceEnumerableFormatter<EnemyModel>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<IEnumerable<BossOrbModel>>())
			{
				MemoryPackFormatterProvider.Register<IEnumerable<BossOrbModel>>((MemoryPackFormatter<IEnumerable<BossOrbModel>>)(object)new InterfaceEnumerableFormatter<BossOrbModel>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref LobbyUpdates? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)3);
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<IEnumerable<Player>>>(ref writer).WriteValue<IEnumerable<Player>>(ref value.Players);
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<IEnumerable<EnemyModel>>>(ref writer).WriteValue<IEnumerable<EnemyModel>>(ref value.Enemies);
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<IEnumerable<BossOrbModel>>>(ref writer).WriteValue<IEnumerable<BossOrbModel>>(ref value.BossOrbs);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref LobbyUpdates? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			IEnumerable<Player> players;
			IEnumerable<EnemyModel> enemies;
			IEnumerable<BossOrbModel> bossOrbs;
			if (b == 3)
			{
				if (value != null)
				{
					players = value.Players;
					enemies = value.Enemies;
					bossOrbs = value.BossOrbs;
					((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<Player>>(ref players);
					((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<EnemyModel>>(ref enemies);
					((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<BossOrbModel>>(ref bossOrbs);
					goto IL_00c7;
				}
				players = ((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<Player>>();
				enemies = ((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<EnemyModel>>();
				bossOrbs = ((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<BossOrbModel>>();
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(LobbyUpdates), (byte)3, b);
					return;
				}
				if (value == null)
				{
					players = null;
					enemies = null;
					bossOrbs = null;
				}
				else
				{
					players = value.Players;
					enemies = value.Enemies;
					bossOrbs = value.BossOrbs;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<Player>>(ref players);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<EnemyModel>>(ref enemies);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<BossOrbModel>>(ref bossOrbs);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00c7;
				}
			}
			value = new LobbyUpdates
			{
				Players = players,
				Enemies = enemies,
				BossOrbs = bossOrbs
			};
			return;
			IL_00c7:
			value.Players = players;
			value.Enemies = enemies;
			value.BossOrbs = bossOrbs;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class PickupApplied : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<PickupApplied>
	{
		[Preserve]
		private sealed class PickupAppliedFormatter : MemoryPackFormatter<PickupApplied>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PickupApplied value)
			{
				PickupApplied.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref PickupApplied value)
			{
				PickupApplied.Deserialize(ref reader, ref value);
			}
		}

		public uint PickupId { get; set; }

		public uint OwnerId { get; set; }

		static PickupApplied()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<PickupApplied>())
			{
				MemoryPackFormatterProvider.Register<PickupApplied>((MemoryPackFormatter<PickupApplied>)(object)new PickupAppliedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<PickupApplied[]>())
			{
				MemoryPackFormatterProvider.Register<PickupApplied[]>((MemoryPackFormatter<PickupApplied[]>)(object)new ArrayFormatter<PickupApplied>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PickupApplied? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint pickupId = value.PickupId;
			uint ownerId = value.OwnerId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref pickupId, ref ownerId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref PickupApplied? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint pickupId = default(uint);
			uint ownerId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					pickupId = value.PickupId;
					ownerId = value.OwnerId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref pickupId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref pickupId, ref ownerId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(PickupApplied), (byte)2, b);
					return;
				}
				if (value == null)
				{
					pickupId = 0u;
					ownerId = 0u;
				}
				else
				{
					pickupId = value.PickupId;
					ownerId = value.OwnerId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref pickupId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new PickupApplied
			{
				PickupId = pickupId,
				OwnerId = ownerId
			};
			return;
			IL_0096:
			value.PickupId = pickupId;
			value.OwnerId = ownerId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class PickupFollowingPlayer : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<PickupFollowingPlayer>
	{
		[Preserve]
		private sealed class PickupFollowingPlayerFormatter : MemoryPackFormatter<PickupFollowingPlayer>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PickupFollowingPlayer value)
			{
				PickupFollowingPlayer.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref PickupFollowingPlayer value)
			{
				PickupFollowingPlayer.Deserialize(ref reader, ref value);
			}
		}

		public uint PickupId { get; set; }

		public uint PlayerId { get; set; }

		static PickupFollowingPlayer()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<PickupFollowingPlayer>())
			{
				MemoryPackFormatterProvider.Register<PickupFollowingPlayer>((MemoryPackFormatter<PickupFollowingPlayer>)(object)new PickupFollowingPlayerFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<PickupFollowingPlayer[]>())
			{
				MemoryPackFormatterProvider.Register<PickupFollowingPlayer[]>((MemoryPackFormatter<PickupFollowingPlayer[]>)(object)new ArrayFormatter<PickupFollowingPlayer>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PickupFollowingPlayer? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint pickupId = value.PickupId;
			uint playerId = value.PlayerId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref pickupId, ref playerId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref PickupFollowingPlayer? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint pickupId = default(uint);
			uint playerId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					pickupId = value.PickupId;
					playerId = value.PlayerId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref pickupId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref pickupId, ref playerId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(PickupFollowingPlayer), (byte)2, b);
					return;
				}
				if (value == null)
				{
					pickupId = 0u;
					playerId = 0u;
				}
				else
				{
					pickupId = value.PickupId;
					playerId = value.PlayerId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref pickupId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new PickupFollowingPlayer
			{
				PickupId = pickupId,
				PlayerId = playerId
			};
			return;
			IL_0096:
			value.PickupId = pickupId;
			value.PlayerId = playerId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class PlayerDied : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<PlayerDied>
	{
		[Preserve]
		private sealed class PlayerDiedFormatter : MemoryPackFormatter<PlayerDied>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PlayerDied value)
			{
				PlayerDied.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref PlayerDied value)
			{
				PlayerDied.Deserialize(ref reader, ref value);
			}
		}

		public uint PlayerId { get; set; }

		static PlayerDied()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<PlayerDied>())
			{
				MemoryPackFormatterProvider.Register<PlayerDied>((MemoryPackFormatter<PlayerDied>)(object)new PlayerDiedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<PlayerDied[]>())
			{
				MemoryPackFormatterProvider.Register<PlayerDied[]>((MemoryPackFormatter<PlayerDied[]>)(object)new ArrayFormatter<PlayerDied>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PlayerDied? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint playerId = value.PlayerId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)1, ref playerId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref PlayerDied? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint playerId = default(uint);
			if (b == 1)
			{
				if (value != null)
				{
					playerId = value.PlayerId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerId);
					goto IL_006b;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerId);
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(PlayerDied), (byte)1, b);
					return;
				}
				playerId = ((value != null) ? value.PlayerId : 0u);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerId);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006b;
				}
			}
			value = new PlayerDied
			{
				PlayerId = playerId
			};
			return;
			IL_006b:
			value.PlayerId = playerId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class PlayerDisconnected : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<PlayerDisconnected>
	{
		[Preserve]
		private sealed class PlayerDisconnectedFormatter : MemoryPackFormatter<PlayerDisconnected>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PlayerDisconnected value)
			{
				PlayerDisconnected.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref PlayerDisconnected value)
			{
				PlayerDisconnected.Deserialize(ref reader, ref value);
			}
		}

		public uint ConnectionId { get; set; }

		static PlayerDisconnected()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<PlayerDisconnected>())
			{
				MemoryPackFormatterProvider.Register<PlayerDisconnected>((MemoryPackFormatter<PlayerDisconnected>)(object)new PlayerDisconnectedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<PlayerDisconnected[]>())
			{
				MemoryPackFormatterProvider.Register<PlayerDisconnected[]>((MemoryPackFormatter<PlayerDisconnected[]>)(object)new ArrayFormatter<PlayerDisconnected>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PlayerDisconnected? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint connectionId = value.ConnectionId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)1, ref connectionId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref PlayerDisconnected? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint connectionId = default(uint);
			if (b == 1)
			{
				if (value != null)
				{
					connectionId = value.ConnectionId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					goto IL_006b;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(PlayerDisconnected), (byte)1, b);
					return;
				}
				connectionId = ((value != null) ? value.ConnectionId : 0u);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006b;
				}
			}
			value = new PlayerDisconnected
			{
				ConnectionId = connectionId
			};
			return;
			IL_006b:
			value.ConnectionId = connectionId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class PlayerUpdate : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<PlayerUpdate>
	{
		[Preserve]
		private sealed class PlayerUpdateFormatter : MemoryPackFormatter<PlayerUpdate>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PlayerUpdate value)
			{
				PlayerUpdate.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref PlayerUpdate value)
			{
				PlayerUpdate.Deserialize(ref reader, ref value);
			}
		}

		public uint ConnectionId { get; set; }

		public Vector3 Position { get; set; }

		public MovementState MovementState { get; set; } = new MovementState();

		public AnimatorState AnimatorState { get; set; } = new AnimatorState();

		public InventoryInfo Inventory { get; set; } = new InventoryInfo();

		public string Name { get; set; } = "";

		public uint Hp { get; set; }

		public uint MaxHp { get; set; }

		public uint Shield { get; set; }

		public uint MaxShield { get; set; }

		static PlayerUpdate()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<PlayerUpdate>())
			{
				MemoryPackFormatterProvider.Register<PlayerUpdate>((MemoryPackFormatter<PlayerUpdate>)(object)new PlayerUpdateFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<PlayerUpdate[]>())
			{
				MemoryPackFormatterProvider.Register<PlayerUpdate[]>((MemoryPackFormatter<PlayerUpdate[]>)(object)new ArrayFormatter<PlayerUpdate>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PlayerUpdate? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint connectionId = value.ConnectionId;
			Vector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, Vector3>((byte)10, ref connectionId, ref position);
			MovementState movementState = value.MovementState;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<MovementState>>(ref writer).WritePackable<MovementState>(ref movementState);
			AnimatorState animatorState = value.AnimatorState;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<AnimatorState>>(ref writer).WritePackable<AnimatorState>(ref animatorState);
			InventoryInfo inventory = value.Inventory;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<InventoryInfo>>(ref writer).WritePackable<InventoryInfo>(ref inventory);
			writer.WriteString(value.Name);
			uint hp = value.Hp;
			uint maxHp = value.MaxHp;
			uint shield = value.Shield;
			uint maxShield = value.MaxShield;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint, uint, uint, uint>(ref hp, ref maxHp, ref shield, ref maxShield);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref PlayerUpdate? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint connectionId = default(uint);
			Vector3 position = default(Vector3);
			MovementState movementState;
			AnimatorState animatorState;
			InventoryInfo inventory;
			uint hp = default(uint);
			uint maxHp = default(uint);
			uint shield = default(uint);
			uint maxShield = default(uint);
			string name;
			if (b == 10)
			{
				if (value != null)
				{
					connectionId = value.ConnectionId;
					position = value.Position;
					movementState = value.MovementState;
					animatorState = value.AnimatorState;
					inventory = value.Inventory;
					name = value.Name;
					hp = value.Hp;
					maxHp = value.MaxHp;
					shield = value.Shield;
					maxShield = value.MaxShield;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadPackable<MovementState>(ref movementState);
					((MemoryPackReader)(ref reader)).ReadPackable<AnimatorState>(ref animatorState);
					((MemoryPackReader)(ref reader)).ReadPackable<InventoryInfo>(ref inventory);
					name = ((MemoryPackReader)(ref reader)).ReadString();
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref hp);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref maxHp);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref shield);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref maxShield);
					goto IL_0219;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, Vector3>(ref connectionId, ref position);
				movementState = ((MemoryPackReader)(ref reader)).ReadPackable<MovementState>();
				animatorState = ((MemoryPackReader)(ref reader)).ReadPackable<AnimatorState>();
				inventory = ((MemoryPackReader)(ref reader)).ReadPackable<InventoryInfo>();
				name = ((MemoryPackReader)(ref reader)).ReadString();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint, uint, uint>(ref hp, ref maxHp, ref shield, ref maxShield);
			}
			else
			{
				if (b > 10)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(PlayerUpdate), (byte)10, b);
					return;
				}
				if (value == null)
				{
					connectionId = 0u;
					position = default(Vector3);
					movementState = null;
					animatorState = null;
					inventory = null;
					name = null;
					hp = 0u;
					maxHp = 0u;
					shield = 0u;
					maxShield = 0u;
				}
				else
				{
					connectionId = value.ConnectionId;
					position = value.Position;
					movementState = value.MovementState;
					animatorState = value.AnimatorState;
					inventory = value.Inventory;
					name = value.Name;
					hp = value.Hp;
					maxHp = value.MaxHp;
					shield = value.Shield;
					maxShield = value.MaxShield;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadPackable<MovementState>(ref movementState);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadPackable<AnimatorState>(ref animatorState);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadPackable<InventoryInfo>(ref inventory);
									if (b != 5)
									{
										name = ((MemoryPackReader)(ref reader)).ReadString();
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref hp);
											if (b != 7)
											{
												((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref maxHp);
												if (b != 8)
												{
													((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref shield);
													if (b != 9)
													{
														((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref maxShield);
														_ = 10;
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0219;
				}
			}
			value = new PlayerUpdate
			{
				ConnectionId = connectionId,
				Position = position,
				MovementState = movementState,
				AnimatorState = animatorState,
				Inventory = inventory,
				Name = name,
				Hp = hp,
				MaxHp = maxHp,
				Shield = shield,
				MaxShield = maxShield
			};
			return;
			IL_0219:
			value.ConnectionId = connectionId;
			value.Position = position;
			value.MovementState = movementState;
			value.AnimatorState = animatorState;
			value.Inventory = inventory;
			value.Name = name;
			value.Hp = hp;
			value.MaxHp = maxHp;
			value.Shield = shield;
			value.MaxShield = maxShield;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class AnimatorState : IMemoryPackable<AnimatorState>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class AnimatorStateFormatter : MemoryPackFormatter<AnimatorState>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref AnimatorState value)
			{
				AnimatorState.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref AnimatorState value)
			{
				AnimatorState.Deserialize(ref reader, ref value);
			}
		}

		public bool IsGrounded { get; set; }

		public bool IsMoving { get; set; }

		public bool IsIdle { get; set; }

		public bool IsGrinding { get; set; }

		public bool IsJumping { get; set; }

		static AnimatorState()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<AnimatorState>())
			{
				MemoryPackFormatterProvider.Register<AnimatorState>((MemoryPackFormatter<AnimatorState>)(object)new AnimatorStateFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<AnimatorState[]>())
			{
				MemoryPackFormatterProvider.Register<AnimatorState[]>((MemoryPackFormatter<AnimatorState[]>)(object)new ArrayFormatter<AnimatorState>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref AnimatorState? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			bool isGrounded = value.IsGrounded;
			bool isMoving = value.IsMoving;
			bool isIdle = value.IsIdle;
			bool isGrinding = value.IsGrinding;
			bool isJumping = value.IsJumping;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<bool>>(ref writer).WriteUnmanagedWithObjectHeader<bool, bool, bool, bool, bool>((byte)5, ref isGrounded, ref isMoving, ref isIdle, ref isGrinding, ref isJumping);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref AnimatorState? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			bool isGrounded = default(bool);
			bool isMoving = default(bool);
			bool isIdle = default(bool);
			bool isGrinding = default(bool);
			bool isJumping = default(bool);
			if (b == 5)
			{
				if (value != null)
				{
					isGrounded = value.IsGrounded;
					isMoving = value.IsMoving;
					isIdle = value.IsIdle;
					isGrinding = value.IsGrinding;
					isJumping = value.IsJumping;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isGrounded);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isMoving);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isIdle);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isGrinding);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isJumping);
					goto IL_0117;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<bool, bool, bool, bool, bool>(ref isGrounded, ref isMoving, ref isIdle, ref isGrinding, ref isJumping);
			}
			else
			{
				if (b > 5)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(AnimatorState), (byte)5, b);
					return;
				}
				if (value == null)
				{
					isGrounded = false;
					isMoving = false;
					isIdle = false;
					isGrinding = false;
					isJumping = false;
				}
				else
				{
					isGrounded = value.IsGrounded;
					isMoving = value.IsMoving;
					isIdle = value.IsIdle;
					isGrinding = value.IsGrinding;
					isJumping = value.IsJumping;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isGrounded);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isMoving);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isIdle);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isGrinding);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isJumping);
									_ = 5;
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0117;
				}
			}
			value = new AnimatorState
			{
				IsGrounded = isGrounded,
				IsMoving = isMoving,
				IsIdle = isIdle,
				IsGrinding = isGrinding,
				IsJumping = isJumping
			};
			return;
			IL_0117:
			value.IsGrounded = isGrounded;
			value.IsMoving = isMoving;
			value.IsIdle = isIdle;
			value.IsGrinding = isGrinding;
			value.IsJumping = isJumping;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class MovementState : IMemoryPackable<MovementState>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class MovementStateFormatter : MemoryPackFormatter<MovementState>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref MovementState value)
			{
				MovementState.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref MovementState value)
			{
				MovementState.Deserialize(ref reader, ref value);
			}
		}

		public QuantizedVector2 AxisInput { get; set; } = new QuantizedVector2();

		public QuantizedVector3 CameraForward { get; set; } = new QuantizedVector3();

		public QuantizedVector3 CameraRight { get; set; } = new QuantizedVector3();

		static MovementState()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<MovementState>())
			{
				MemoryPackFormatterProvider.Register<MovementState>((MemoryPackFormatter<MovementState>)(object)new MovementStateFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<MovementState[]>())
			{
				MemoryPackFormatterProvider.Register<MovementState[]>((MemoryPackFormatter<MovementState[]>)(object)new ArrayFormatter<MovementState>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref MovementState? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)3);
			QuantizedVector2 axisInput = value.AxisInput;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector2>>(ref writer).WritePackable<QuantizedVector2>(ref axisInput);
			QuantizedVector3 cameraForward = value.CameraForward;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref cameraForward);
			QuantizedVector3 cameraRight = value.CameraRight;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref cameraRight);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref MovementState? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			QuantizedVector2 axisInput;
			QuantizedVector3 cameraForward;
			QuantizedVector3 cameraRight;
			if (b == 3)
			{
				if (value != null)
				{
					axisInput = value.AxisInput;
					cameraForward = value.CameraForward;
					cameraRight = value.CameraRight;
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector2>(ref axisInput);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref cameraForward);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref cameraRight);
					goto IL_00c7;
				}
				axisInput = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector2>();
				cameraForward = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				cameraRight = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(MovementState), (byte)3, b);
					return;
				}
				if (value == null)
				{
					axisInput = null;
					cameraForward = null;
					cameraRight = null;
				}
				else
				{
					axisInput = value.AxisInput;
					cameraForward = value.CameraForward;
					cameraRight = value.CameraRight;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector2>(ref axisInput);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref cameraForward);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref cameraRight);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00c7;
				}
			}
			value = new MovementState
			{
				AxisInput = axisInput,
				CameraForward = cameraForward,
				CameraRight = cameraRight
			};
			return;
			IL_00c7:
			value.AxisInput = axisInput;
			value.CameraForward = cameraForward;
			value.CameraRight = cameraRight;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class ProjectileDone : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<ProjectileDone>
	{
		[Preserve]
		private sealed class ProjectileDoneFormatter : MemoryPackFormatter<ProjectileDone>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ProjectileDone value)
			{
				ProjectileDone.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref ProjectileDone value)
			{
				ProjectileDone.Deserialize(ref reader, ref value);
			}
		}

		public uint ProjectileId { get; set; }

		public uint SenderConnectionId { get; set; }

		static ProjectileDone()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<ProjectileDone>())
			{
				MemoryPackFormatterProvider.Register<ProjectileDone>((MemoryPackFormatter<ProjectileDone>)(object)new ProjectileDoneFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<ProjectileDone[]>())
			{
				MemoryPackFormatterProvider.Register<ProjectileDone[]>((MemoryPackFormatter<ProjectileDone[]>)(object)new ArrayFormatter<ProjectileDone>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ProjectileDone? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint projectileId = value.ProjectileId;
			uint senderConnectionId = value.SenderConnectionId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref projectileId, ref senderConnectionId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref ProjectileDone? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint projectileId = default(uint);
			uint senderConnectionId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					projectileId = value.ProjectileId;
					senderConnectionId = value.SenderConnectionId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref projectileId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref senderConnectionId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref projectileId, ref senderConnectionId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(ProjectileDone), (byte)2, b);
					return;
				}
				if (value == null)
				{
					projectileId = 0u;
					senderConnectionId = 0u;
				}
				else
				{
					projectileId = value.ProjectileId;
					senderConnectionId = value.SenderConnectionId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref projectileId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref senderConnectionId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new ProjectileDone
			{
				ProjectileId = projectileId,
				SenderConnectionId = senderConnectionId
			};
			return;
			IL_0096:
			value.ProjectileId = projectileId;
			value.SenderConnectionId = senderConnectionId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class ProjectilesUpdate : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<ProjectilesUpdate>
	{
		[Preserve]
		private sealed class ProjectilesUpdateFormatter : MemoryPackFormatter<ProjectilesUpdate>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ProjectilesUpdate value)
			{
				ProjectilesUpdate.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref ProjectilesUpdate value)
			{
				ProjectilesUpdate.Deserialize(ref reader, ref value);
			}
		}

		public ICollection<Projectile> Projectiles { get; set; } = new List<Projectile>();

		static ProjectilesUpdate()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<ProjectilesUpdate>())
			{
				MemoryPackFormatterProvider.Register<ProjectilesUpdate>((MemoryPackFormatter<ProjectilesUpdate>)(object)new ProjectilesUpdateFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<ProjectilesUpdate[]>())
			{
				MemoryPackFormatterProvider.Register<ProjectilesUpdate[]>((MemoryPackFormatter<ProjectilesUpdate[]>)(object)new ArrayFormatter<ProjectilesUpdate>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<ICollection<Projectile>>())
			{
				MemoryPackFormatterProvider.Register<ICollection<Projectile>>((MemoryPackFormatter<ICollection<Projectile>>)(object)new InterfaceCollectionFormatter<Projectile>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ProjectilesUpdate? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)1);
			ICollection<Projectile> projectiles = value.Projectiles;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<ICollection<Projectile>>>(ref writer).WriteValue<ICollection<Projectile>>(ref projectiles);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref ProjectilesUpdate? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			ICollection<Projectile> projectiles;
			if (b == 1)
			{
				if (value != null)
				{
					projectiles = value.Projectiles;
					((MemoryPackReader)(ref reader)).ReadValue<ICollection<Projectile>>(ref projectiles);
					goto IL_006a;
				}
				projectiles = ((MemoryPackReader)(ref reader)).ReadValue<ICollection<Projectile>>();
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(ProjectilesUpdate), (byte)1, b);
					return;
				}
				projectiles = ((value != null) ? value.Projectiles : null);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadValue<ICollection<Projectile>>(ref projectiles);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006a;
				}
			}
			value = new ProjectilesUpdate
			{
				Projectiles = projectiles
			};
			return;
			IL_006a:
			value.Projectiles = projectiles;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class RetargetedEnemies : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<RetargetedEnemies>
	{
		[Preserve]
		private sealed class RetargetedEnemiesFormatter : MemoryPackFormatter<RetargetedEnemies>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref RetargetedEnemies value)
			{
				RetargetedEnemies.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref RetargetedEnemies value)
			{
				RetargetedEnemies.Deserialize(ref reader, ref value);
			}
		}

		public IEnumerable<(uint, uint)> Enemy_NewTargetids { get; set; } = Enumerable.Empty<(uint, uint)>();

		static RetargetedEnemies()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<RetargetedEnemies>())
			{
				MemoryPackFormatterProvider.Register<RetargetedEnemies>((MemoryPackFormatter<RetargetedEnemies>)(object)new RetargetedEnemiesFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<RetargetedEnemies[]>())
			{
				MemoryPackFormatterProvider.Register<RetargetedEnemies[]>((MemoryPackFormatter<RetargetedEnemies[]>)(object)new ArrayFormatter<RetargetedEnemies>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<IEnumerable<(uint, uint)>>())
			{
				MemoryPackFormatterProvider.Register<IEnumerable<(uint, uint)>>((MemoryPackFormatter<IEnumerable<(uint, uint)>>)(object)new InterfaceEnumerableFormatter<(uint, uint)>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<(uint, uint)>())
			{
				MemoryPackFormatterProvider.Register<(uint, uint)>((MemoryPackFormatter<(uint, uint)>)(object)new ValueTupleFormatter<uint, uint>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref RetargetedEnemies? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)1);
			IEnumerable<(uint, uint)> enemy_NewTargetids = value.Enemy_NewTargetids;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<IEnumerable<(uint, uint)>>>(ref writer).WriteValue<IEnumerable<(uint, uint)>>(ref enemy_NewTargetids);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref RetargetedEnemies? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			IEnumerable<(uint, uint)> enemy_NewTargetids;
			if (b == 1)
			{
				if (value != null)
				{
					enemy_NewTargetids = value.Enemy_NewTargetids;
					((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<(uint, uint)>>(ref enemy_NewTargetids);
					goto IL_006a;
				}
				enemy_NewTargetids = ((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<(uint, uint)>>();
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(RetargetedEnemies), (byte)1, b);
					return;
				}
				enemy_NewTargetids = ((value != null) ? value.Enemy_NewTargetids : null);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<(uint, uint)>>(ref enemy_NewTargetids);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006a;
				}
			}
			value = new RetargetedEnemies
			{
				Enemy_NewTargetids = enemy_NewTargetids
			};
			return;
			IL_006a:
			value.Enemy_NewTargetids = enemy_NewTargetids;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class RunStarted : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<RunStarted>
	{
		[Preserve]
		private sealed class RunStartedFormatter : MemoryPackFormatter<RunStarted>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref RunStarted value)
			{
				RunStarted.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref RunStarted value)
			{
				RunStarted.Deserialize(ref reader, ref value);
			}
		}

		public int MapData { get; set; }

		public string StageData { get; set; }

		public int MapTierIndex { get; set; }

		public int MusicTrackIndex { get; set; }

		public string ChallengeName { get; set; }

		static RunStarted()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<RunStarted>())
			{
				MemoryPackFormatterProvider.Register<RunStarted>((MemoryPackFormatter<RunStarted>)(object)new RunStartedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<RunStarted[]>())
			{
				MemoryPackFormatterProvider.Register<RunStarted[]>((MemoryPackFormatter<RunStarted[]>)(object)new ArrayFormatter<RunStarted>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref RunStarted? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			int mapData = value.MapData;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanagedWithObjectHeader<int>((byte)5, ref mapData);
			writer.WriteString(value.StageData);
			int mapTierIndex = value.MapTierIndex;
			int musicTrackIndex = value.MusicTrackIndex;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanaged<int, int>(ref mapTierIndex, ref musicTrackIndex);
			writer.WriteString(value.ChallengeName);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref RunStarted? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			int mapData = default(int);
			int mapTierIndex = default(int);
			int musicTrackIndex = default(int);
			string stageData;
			string challengeName;
			if (b == 5)
			{
				if (value != null)
				{
					mapData = value.MapData;
					stageData = value.StageData;
					mapTierIndex = value.MapTierIndex;
					musicTrackIndex = value.MusicTrackIndex;
					challengeName = value.ChallengeName;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref mapData);
					stageData = ((MemoryPackReader)(ref reader)).ReadString();
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref mapTierIndex);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref musicTrackIndex);
					challengeName = ((MemoryPackReader)(ref reader)).ReadString();
					goto IL_0129;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref mapData);
				stageData = ((MemoryPackReader)(ref reader)).ReadString();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int, int>(ref mapTierIndex, ref musicTrackIndex);
				challengeName = ((MemoryPackReader)(ref reader)).ReadString();
			}
			else
			{
				if (b > 5)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(RunStarted), (byte)5, b);
					return;
				}
				if (value == null)
				{
					mapData = 0;
					stageData = null;
					mapTierIndex = 0;
					musicTrackIndex = 0;
					challengeName = null;
				}
				else
				{
					mapData = value.MapData;
					stageData = value.StageData;
					mapTierIndex = value.MapTierIndex;
					musicTrackIndex = value.MusicTrackIndex;
					challengeName = value.ChallengeName;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref mapData);
					if (b != 1)
					{
						stageData = ((MemoryPackReader)(ref reader)).ReadString();
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref mapTierIndex);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref musicTrackIndex);
								if (b != 4)
								{
									challengeName = ((MemoryPackReader)(ref reader)).ReadString();
									_ = 5;
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0129;
				}
			}
			value = new RunStarted
			{
				MapData = mapData,
				StageData = stageData,
				MapTierIndex = mapTierIndex,
				MusicTrackIndex = musicTrackIndex,
				ChallengeName = challengeName
			};
			return;
			IL_0129:
			value.MapData = mapData;
			value.StageData = stageData;
			value.MapTierIndex = mapTierIndex;
			value.MusicTrackIndex = musicTrackIndex;
			value.ChallengeName = challengeName;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SelectedCharacter : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<SelectedCharacter>
	{
		[Preserve]
		private sealed class SelectedCharacterFormatter : MemoryPackFormatter<SelectedCharacter>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SelectedCharacter value)
			{
				SelectedCharacter.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SelectedCharacter value)
			{
				SelectedCharacter.Deserialize(ref reader, ref value);
			}
		}

		public uint ConnectionId { get; set; }

		public uint Character { get; set; }

		public string Skin { get; set; } = "";

		static SelectedCharacter()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SelectedCharacter>())
			{
				MemoryPackFormatterProvider.Register<SelectedCharacter>((MemoryPackFormatter<SelectedCharacter>)(object)new SelectedCharacterFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SelectedCharacter[]>())
			{
				MemoryPackFormatterProvider.Register<SelectedCharacter[]>((MemoryPackFormatter<SelectedCharacter[]>)(object)new ArrayFormatter<SelectedCharacter>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SelectedCharacter? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint connectionId = value.ConnectionId;
			uint character = value.Character;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)3, ref connectionId, ref character);
			writer.WriteString(value.Skin);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SelectedCharacter? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint connectionId = default(uint);
			uint character = default(uint);
			string skin;
			if (b == 3)
			{
				if (value != null)
				{
					connectionId = value.ConnectionId;
					character = value.Character;
					skin = value.Skin;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref character);
					skin = ((MemoryPackReader)(ref reader)).ReadString();
					goto IL_00c1;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref connectionId, ref character);
				skin = ((MemoryPackReader)(ref reader)).ReadString();
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SelectedCharacter), (byte)3, b);
					return;
				}
				if (value == null)
				{
					connectionId = 0u;
					character = 0u;
					skin = null;
				}
				else
				{
					connectionId = value.ConnectionId;
					character = value.Character;
					skin = value.Skin;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref character);
						if (b != 2)
						{
							skin = ((MemoryPackReader)(ref reader)).ReadString();
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00c1;
				}
			}
			value = new SelectedCharacter
			{
				ConnectionId = connectionId,
				Character = character,
				Skin = skin
			};
			return;
			IL_00c1:
			value.ConnectionId = connectionId;
			value.Character = character;
			value.Skin = skin;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedChest : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<SpawnedChest>
	{
		[Preserve]
		private sealed class SpawnedChestFormatter : MemoryPackFormatter<SpawnedChest>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedChest value)
			{
				SpawnedChest.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedChest value)
			{
				SpawnedChest.Deserialize(ref reader, ref value);
			}
		}

		public Vector3 Position { get; set; }

		public Quaternion Rotation { get; set; }

		public uint ChestId { get; set; }

		static SpawnedChest()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedChest>())
			{
				MemoryPackFormatterProvider.Register<SpawnedChest>((MemoryPackFormatter<SpawnedChest>)(object)new SpawnedChestFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedChest[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedChest[]>((MemoryPackFormatter<SpawnedChest[]>)(object)new ArrayFormatter<SpawnedChest>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedChest? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			Vector3 position = value.Position;
			Quaternion rotation = value.Rotation;
			uint chestId = value.ChestId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<Vector3>>(ref writer).WriteUnmanagedWithObjectHeader<Vector3, Quaternion, uint>((byte)3, ref position, ref rotation, ref chestId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedChest? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			Vector3 position = default(Vector3);
			Quaternion rotation = default(Quaternion);
			uint chestId = default(uint);
			if (b == 3)
			{
				if (value != null)
				{
					position = value.Position;
					rotation = value.Rotation;
					chestId = value.ChestId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Quaternion>(ref rotation);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref chestId);
					goto IL_00ca;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3, Quaternion, uint>(ref position, ref rotation, ref chestId);
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedChest), (byte)3, b);
					return;
				}
				if (value == null)
				{
					position = default(Vector3);
					rotation = default(Quaternion);
					chestId = 0u;
				}
				else
				{
					position = value.Position;
					rotation = value.Rotation;
					chestId = value.ChestId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<Quaternion>(ref rotation);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref chestId);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00ca;
				}
			}
			value = new SpawnedChest
			{
				Position = position,
				Rotation = rotation,
				ChestId = chestId
			};
			return;
			IL_00ca:
			value.Position = position;
			value.Rotation = rotation;
			value.ChestId = chestId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedEnemy : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<SpawnedEnemy>
	{
		[Preserve]
		private sealed class SpawnedEnemyFormatter : MemoryPackFormatter<SpawnedEnemy>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedEnemy value)
			{
				SpawnedEnemy.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedEnemy value)
			{
				SpawnedEnemy.Deserialize(ref reader, ref value);
			}
		}

		public int Name { get; set; }

		public uint Id { get; set; }

		public bool ShouldForce { get; set; }

		public int Flag { get; set; }

		public Vector3 Position { get; set; }

		public int Wave { get; set; }

		public bool CanBeElite { get; set; }

		public uint TargetId { get; set; }

		public float Hp { get; set; }

		public float ExtraSizeMultiplier { get; set; }

		public uint? ReviverId { get; set; }

		static SpawnedEnemy()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedEnemy>())
			{
				MemoryPackFormatterProvider.Register<SpawnedEnemy>((MemoryPackFormatter<SpawnedEnemy>)(object)new SpawnedEnemyFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedEnemy[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedEnemy[]>((MemoryPackFormatter<SpawnedEnemy[]>)(object)new ArrayFormatter<SpawnedEnemy>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<uint?>())
			{
				MemoryPackFormatterProvider.Register<uint?>((MemoryPackFormatter<uint?>)(object)new NullableFormatter<uint>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedEnemy? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			int name = value.Name;
			uint id = value.Id;
			bool shouldForce = value.ShouldForce;
			int flag = value.Flag;
			Vector3 position = value.Position;
			int wave = value.Wave;
			bool canBeElite = value.CanBeElite;
			uint targetId = value.TargetId;
			float hp = value.Hp;
			float extraSizeMultiplier = value.ExtraSizeMultiplier;
			uint? reviverId = value.ReviverId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).DangerousWriteUnmanagedWithObjectHeader<int, uint, bool, int, Vector3, int, bool, uint, float, float, uint?>((byte)11, ref name, ref id, ref shouldForce, ref flag, ref position, ref wave, ref canBeElite, ref targetId, ref hp, ref extraSizeMultiplier, ref reviverId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedEnemy? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			int name = default(int);
			uint id = default(uint);
			bool shouldForce = default(bool);
			int flag = default(int);
			Vector3 position = default(Vector3);
			int wave = default(int);
			bool canBeElite = default(bool);
			uint targetId = default(uint);
			float hp = default(float);
			float extraSizeMultiplier = default(float);
			uint? reviverId = default(uint?);
			if (b == 11)
			{
				if (value != null)
				{
					name = value.Name;
					id = value.Id;
					shouldForce = value.ShouldForce;
					flag = value.Flag;
					position = value.Position;
					wave = value.Wave;
					canBeElite = value.CanBeElite;
					targetId = value.TargetId;
					hp = value.Hp;
					extraSizeMultiplier = value.ExtraSizeMultiplier;
					reviverId = value.ReviverId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref name);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref shouldForce);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref flag);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref wave);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref canBeElite);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref targetId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref hp);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref extraSizeMultiplier);
					((MemoryPackReader)(ref reader)).DangerousReadUnmanaged<uint?>(ref reviverId);
					goto IL_0237;
				}
				((MemoryPackReader)(ref reader)).DangerousReadUnmanaged<int, uint, bool, int, Vector3, int, bool, uint, float, float, uint?>(ref name, ref id, ref shouldForce, ref flag, ref position, ref wave, ref canBeElite, ref targetId, ref hp, ref extraSizeMultiplier, ref reviverId);
			}
			else
			{
				if (b > 11)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedEnemy), (byte)11, b);
					return;
				}
				if (value == null)
				{
					name = 0;
					id = 0u;
					shouldForce = false;
					flag = 0;
					position = default(Vector3);
					wave = 0;
					canBeElite = false;
					targetId = 0u;
					hp = 0f;
					extraSizeMultiplier = 0f;
					reviverId = null;
				}
				else
				{
					name = value.Name;
					id = value.Id;
					shouldForce = value.ShouldForce;
					flag = value.Flag;
					position = value.Position;
					wave = value.Wave;
					canBeElite = value.CanBeElite;
					targetId = value.TargetId;
					hp = value.Hp;
					extraSizeMultiplier = value.ExtraSizeMultiplier;
					reviverId = value.ReviverId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref name);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref shouldForce);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref flag);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
									if (b != 5)
									{
										((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref wave);
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref canBeElite);
											if (b != 7)
											{
												((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref targetId);
												if (b != 8)
												{
													((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref hp);
													if (b != 9)
													{
														((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref extraSizeMultiplier);
														if (b != 10)
														{
															((MemoryPackReader)(ref reader)).DangerousReadUnmanaged<uint?>(ref reviverId);
															_ = 11;
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0237;
				}
			}
			value = new SpawnedEnemy
			{
				Name = name,
				Id = id,
				ShouldForce = shouldForce,
				Flag = flag,
				Position = position,
				Wave = wave,
				CanBeElite = canBeElite,
				TargetId = targetId,
				Hp = hp,
				ExtraSizeMultiplier = extraSizeMultiplier,
				ReviverId = reviverId
			};
			return;
			IL_0237:
			value.Name = name;
			value.Id = id;
			value.ShouldForce = shouldForce;
			value.Flag = flag;
			value.Position = position;
			value.Wave = wave;
			value.CanBeElite = canBeElite;
			value.TargetId = targetId;
			value.Hp = hp;
			value.ExtraSizeMultiplier = extraSizeMultiplier;
			value.ReviverId = reviverId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedEnemySpecialAttack : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<SpawnedEnemySpecialAttack>
	{
		[Preserve]
		private sealed class SpawnedEnemySpecialAttackFormatter : MemoryPackFormatter<SpawnedEnemySpecialAttack>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedEnemySpecialAttack value)
			{
				SpawnedEnemySpecialAttack.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedEnemySpecialAttack value)
			{
				SpawnedEnemySpecialAttack.Deserialize(ref reader, ref value);
			}
		}

		public uint EnemyId { get; set; }

		public string AttackName { get; set; }

		public uint TargetId { get; set; }

		static SpawnedEnemySpecialAttack()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedEnemySpecialAttack>())
			{
				MemoryPackFormatterProvider.Register<SpawnedEnemySpecialAttack>((MemoryPackFormatter<SpawnedEnemySpecialAttack>)(object)new SpawnedEnemySpecialAttackFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedEnemySpecialAttack[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedEnemySpecialAttack[]>((MemoryPackFormatter<SpawnedEnemySpecialAttack[]>)(object)new ArrayFormatter<SpawnedEnemySpecialAttack>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedEnemySpecialAttack? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint enemyId = value.EnemyId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)3, ref enemyId);
			writer.WriteString(value.AttackName);
			uint targetId = value.TargetId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint>(ref targetId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedEnemySpecialAttack? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint enemyId = default(uint);
			uint targetId = default(uint);
			string attackName;
			if (b == 3)
			{
				if (value != null)
				{
					enemyId = value.EnemyId;
					attackName = value.AttackName;
					targetId = value.TargetId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref enemyId);
					attackName = ((MemoryPackReader)(ref reader)).ReadString();
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref targetId);
					goto IL_00c7;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref enemyId);
				attackName = ((MemoryPackReader)(ref reader)).ReadString();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref targetId);
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedEnemySpecialAttack), (byte)3, b);
					return;
				}
				if (value == null)
				{
					enemyId = 0u;
					attackName = null;
					targetId = 0u;
				}
				else
				{
					enemyId = value.EnemyId;
					attackName = value.AttackName;
					targetId = value.TargetId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref enemyId);
					if (b != 1)
					{
						attackName = ((MemoryPackReader)(ref reader)).ReadString();
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref targetId);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00c7;
				}
			}
			value = new SpawnedEnemySpecialAttack
			{
				EnemyId = enemyId,
				AttackName = attackName,
				TargetId = targetId
			};
			return;
			IL_00c7:
			value.EnemyId = enemyId;
			value.AttackName = attackName;
			value.TargetId = targetId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedObject : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<SpawnedObject>
	{
		[Preserve]
		private sealed class SpawnedObjectFormatter : MemoryPackFormatter<SpawnedObject>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedObject value)
			{
				SpawnedObject.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedObject value)
			{
				SpawnedObject.Deserialize(ref reader, ref value);
			}
		}

		public Vector3 Position = Vector3.Zero;

		public Quaternion Rotation = Quaternion.Identity;

		public Vector3 Scale = Vector3.One;

		public string PrefabName = string.Empty;

		public Specific SpecificData = new Specific();

		public uint Id { get; set; }

		static SpawnedObject()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedObject>())
			{
				MemoryPackFormatterProvider.Register<SpawnedObject>((MemoryPackFormatter<SpawnedObject>)(object)new SpawnedObjectFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedObject[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedObject[]>((MemoryPackFormatter<SpawnedObject[]>)(object)new ArrayFormatter<SpawnedObject>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedObject? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<Vector3>>(ref writer).WriteUnmanagedWithObjectHeader<Vector3, Quaternion, Vector3>((byte)6, ref value.Position, ref value.Rotation, ref value.Scale);
			writer.WriteString(value.PrefabName);
			uint id = value.Id;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint>(ref id);
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<Specific>>(ref writer).WritePackable<Specific>(ref value.SpecificData);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedObject? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			Vector3 position = default(Vector3);
			Quaternion rotation = default(Quaternion);
			Vector3 scale = default(Vector3);
			uint id = default(uint);
			Specific specificData;
			string prefabName;
			if (b == 6)
			{
				if (value != null)
				{
					position = value.Position;
					rotation = value.Rotation;
					scale = value.Scale;
					prefabName = value.PrefabName;
					id = value.Id;
					specificData = value.SpecificData;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Quaternion>(ref rotation);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref scale);
					prefabName = ((MemoryPackReader)(ref reader)).ReadString();
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadPackable<Specific>(ref specificData);
					goto IL_0169;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3, Quaternion, Vector3>(ref position, ref rotation, ref scale);
				prefabName = ((MemoryPackReader)(ref reader)).ReadString();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
				specificData = ((MemoryPackReader)(ref reader)).ReadPackable<Specific>();
			}
			else
			{
				if (b > 6)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedObject), (byte)6, b);
					return;
				}
				if (value == null)
				{
					position = default(Vector3);
					rotation = default(Quaternion);
					scale = default(Vector3);
					prefabName = null;
					id = 0u;
					specificData = null;
				}
				else
				{
					position = value.Position;
					rotation = value.Rotation;
					scale = value.Scale;
					prefabName = value.PrefabName;
					id = value.Id;
					specificData = value.SpecificData;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<Quaternion>(ref rotation);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref scale);
							if (b != 3)
							{
								prefabName = ((MemoryPackReader)(ref reader)).ReadString();
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
									if (b != 5)
									{
										((MemoryPackReader)(ref reader)).ReadPackable<Specific>(ref specificData);
										_ = 6;
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0169;
				}
			}
			value = new SpawnedObject
			{
				Position = position,
				Rotation = rotation,
				Scale = scale,
				PrefabName = prefabName,
				Id = id,
				SpecificData = specificData
			};
			return;
			IL_0169:
			value.Position = position;
			value.Rotation = rotation;
			value.Scale = scale;
			value.PrefabName = prefabName;
			value.Id = id;
			value.SpecificData = specificData;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class Specific : IMemoryPackable<Specific>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class SpecificFormatter : MemoryPackFormatter<Specific>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref Specific value)
			{
				Specific.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref Specific value)
			{
				Specific.Deserialize(ref reader, ref value);
			}
		}

		public int ShadyGuyRarity { get; set; }

		static Specific()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<Specific>())
			{
				MemoryPackFormatterProvider.Register<Specific>((MemoryPackFormatter<Specific>)(object)new SpecificFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<Specific[]>())
			{
				MemoryPackFormatterProvider.Register<Specific[]>((MemoryPackFormatter<Specific[]>)(object)new ArrayFormatter<Specific>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref Specific? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			int shadyGuyRarity = value.ShadyGuyRarity;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanagedWithObjectHeader<int>((byte)1, ref shadyGuyRarity);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref Specific? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			int shadyGuyRarity = default(int);
			if (b == 1)
			{
				if (value != null)
				{
					shadyGuyRarity = value.ShadyGuyRarity;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref shadyGuyRarity);
					goto IL_006b;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref shadyGuyRarity);
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(Specific), (byte)1, b);
					return;
				}
				shadyGuyRarity = ((value != null) ? value.ShadyGuyRarity : 0);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref shadyGuyRarity);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006b;
				}
			}
			value = new Specific
			{
				ShadyGuyRarity = shadyGuyRarity
			};
			return;
			IL_006b:
			value.ShadyGuyRarity = shadyGuyRarity;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedPickup : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<SpawnedPickup>
	{
		[Preserve]
		private sealed class SpawnedPickupFormatter : MemoryPackFormatter<SpawnedPickup>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedPickup value)
			{
				SpawnedPickup.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedPickup value)
			{
				SpawnedPickup.Deserialize(ref reader, ref value);
			}
		}

		public uint Id { get; set; }

		public int Pickup { get; set; }

		public Vector3 Position { get; set; }

		public int Value { get; set; }

		static SpawnedPickup()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedPickup>())
			{
				MemoryPackFormatterProvider.Register<SpawnedPickup>((MemoryPackFormatter<SpawnedPickup>)(object)new SpawnedPickupFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedPickup[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedPickup[]>((MemoryPackFormatter<SpawnedPickup[]>)(object)new ArrayFormatter<SpawnedPickup>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedPickup? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint id = value.Id;
			int pickup = value.Pickup;
			Vector3 position = value.Position;
			int value2 = value.Value;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, int, Vector3, int>((byte)4, ref id, ref pickup, ref position, ref value2);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedPickup? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint id = default(uint);
			int pickup = default(int);
			Vector3 position = default(Vector3);
			int value2 = default(int);
			if (b == 4)
			{
				if (value != null)
				{
					id = value.Id;
					pickup = value.Pickup;
					position = value.Position;
					value2 = value.Value;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref pickup);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref value2);
					goto IL_00f2;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, int, Vector3, int>(ref id, ref pickup, ref position, ref value2);
			}
			else
			{
				if (b > 4)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedPickup), (byte)4, b);
					return;
				}
				if (value == null)
				{
					id = 0u;
					pickup = 0;
					position = default(Vector3);
					value2 = 0;
				}
				else
				{
					id = value.Id;
					pickup = value.Pickup;
					position = value.Position;
					value2 = value.Value;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref pickup);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref value2);
								_ = 4;
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_00f2;
				}
			}
			value = new SpawnedPickup
			{
				Id = id,
				Pickup = pickup,
				Position = position,
				Value = value2
			};
			return;
			IL_00f2:
			value.Id = id;
			value.Pickup = pickup;
			value.Position = position;
			value.Value = value2;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedPickupOrb : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<SpawnedPickupOrb>
	{
		[Preserve]
		private sealed class SpawnedPickupOrbFormatter : MemoryPackFormatter<SpawnedPickupOrb>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedPickupOrb value)
			{
				SpawnedPickupOrb.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedPickupOrb value)
			{
				SpawnedPickupOrb.Deserialize(ref reader, ref value);
			}
		}

		public int Pickup { get; set; }

		public Vector3 Position { get; set; }

		static SpawnedPickupOrb()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedPickupOrb>())
			{
				MemoryPackFormatterProvider.Register<SpawnedPickupOrb>((MemoryPackFormatter<SpawnedPickupOrb>)(object)new SpawnedPickupOrbFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedPickupOrb[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedPickupOrb[]>((MemoryPackFormatter<SpawnedPickupOrb[]>)(object)new ArrayFormatter<SpawnedPickupOrb>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedPickupOrb? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			int pickup = value.Pickup;
			Vector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanagedWithObjectHeader<int, Vector3>((byte)2, ref pickup, ref position);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedPickupOrb? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			int pickup = default(int);
			Vector3 position = default(Vector3);
			if (b == 2)
			{
				if (value != null)
				{
					pickup = value.Pickup;
					position = value.Position;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref pickup);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
					goto IL_009c;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int, Vector3>(ref pickup, ref position);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedPickupOrb), (byte)2, b);
					return;
				}
				if (value == null)
				{
					pickup = 0;
					position = default(Vector3);
				}
				else
				{
					pickup = value.Pickup;
					position = value.Position;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref pickup);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_009c;
				}
			}
			value = new SpawnedPickupOrb
			{
				Pickup = pickup,
				Position = position
			};
			return;
			IL_009c:
			value.Pickup = pickup;
			value.Position = position;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	[MemoryPackUnion(0, typeof(SpawnedProjectile))]
	[MemoryPackUnion(1, typeof(SpawnedAxeProjectile))]
	[MemoryPackUnion(2, typeof(SpawnedBlackHoleProjectile))]
	[MemoryPackUnion(3, typeof(SpawnedCringeSwordProjectile))]
	[MemoryPackUnion(4, typeof(SpawnedFireFieldProjectile))]
	[MemoryPackUnion(5, typeof(SpawnedHeroSwordProjectile))]
	[MemoryPackUnion(6, typeof(SpawnedRocketProjectile))]
	[MemoryPackUnion(7, typeof(SpawnedShotgunProjectile))]
	[MemoryPackUnion(8, typeof(SpawnedDexecutionerProjectile))]
	[MemoryPackUnion(9, typeof(SpawnedRevolverProjectile))]
	[MemoryPackUnion(10, typeof(SpawnedSniperProjectile))]
	public abstract class AbstractSpawnedProjectile : IGameNetworkMessage, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class AbstractSpawnedProjectileFormatter : MemoryPackFormatter<AbstractSpawnedProjectile>
		{
			private static readonly Dictionary<Type, ushort> __typeToTag = new Dictionary<Type, ushort>(11)
			{
				{
					typeof(SpawnedProjectile),
					0
				},
				{
					typeof(SpawnedAxeProjectile),
					1
				},
				{
					typeof(SpawnedBlackHoleProjectile),
					2
				},
				{
					typeof(SpawnedCringeSwordProjectile),
					3
				},
				{
					typeof(SpawnedFireFieldProjectile),
					4
				},
				{
					typeof(SpawnedHeroSwordProjectile),
					5
				},
				{
					typeof(SpawnedRocketProjectile),
					6
				},
				{
					typeof(SpawnedShotgunProjectile),
					7
				},
				{
					typeof(SpawnedDexecutionerProjectile),
					8
				},
				{
					typeof(SpawnedRevolverProjectile),
					9
				},
				{
					typeof(SpawnedSniperProjectile),
					10
				}
			};

			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref AbstractSpawnedProjectile? value)
			{
				ushort value2;
				if (value == null)
				{
					writer.WriteNullUnionHeader();
				}
				else if (__typeToTag.TryGetValue(value.GetType(), out value2))
				{
					writer.WriteUnionHeader(value2);
					switch (value2)
					{
					case 0:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedProjectile>>(ref writer).WritePackable<SpawnedProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedProjectile>(ref value));
						break;
					case 1:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedAxeProjectile>>(ref writer).WritePackable<SpawnedAxeProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedAxeProjectile>(ref value));
						break;
					case 2:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedBlackHoleProjectile>>(ref writer).WritePackable<SpawnedBlackHoleProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedBlackHoleProjectile>(ref value));
						break;
					case 3:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedCringeSwordProjectile>>(ref writer).WritePackable<SpawnedCringeSwordProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedCringeSwordProjectile>(ref value));
						break;
					case 4:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedFireFieldProjectile>>(ref writer).WritePackable<SpawnedFireFieldProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedFireFieldProjectile>(ref value));
						break;
					case 5:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedHeroSwordProjectile>>(ref writer).WritePackable<SpawnedHeroSwordProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedHeroSwordProjectile>(ref value));
						break;
					case 6:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedRocketProjectile>>(ref writer).WritePackable<SpawnedRocketProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedRocketProjectile>(ref value));
						break;
					case 7:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedShotgunProjectile>>(ref writer).WritePackable<SpawnedShotgunProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedShotgunProjectile>(ref value));
						break;
					case 8:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedDexecutionerProjectile>>(ref writer).WritePackable<SpawnedDexecutionerProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedDexecutionerProjectile>(ref value));
						break;
					case 9:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedRevolverProjectile>>(ref writer).WritePackable<SpawnedRevolverProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedRevolverProjectile>(ref value));
						break;
					case 10:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<SpawnedSniperProjectile>>(ref writer).WritePackable<SpawnedSniperProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedSniperProjectile>(ref value));
						break;
					}
				}
				else
				{
					MemoryPackSerializationException.ThrowNotFoundInUnionType(value.GetType(), typeof(AbstractSpawnedProjectile));
				}
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref AbstractSpawnedProjectile? value)
			{
				ushort num = default(ushort);
				if (!((MemoryPackReader)(ref reader)).TryReadUnionHeader(ref num))
				{
					value = null;
					return;
				}
				switch (num)
				{
				case 0:
					if (value is SpawnedProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedProjectile>();
					}
					break;
				case 1:
					if (value is SpawnedAxeProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedAxeProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedAxeProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedAxeProjectile>();
					}
					break;
				case 2:
					if (value is SpawnedBlackHoleProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedBlackHoleProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedBlackHoleProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedBlackHoleProjectile>();
					}
					break;
				case 3:
					if (value is SpawnedCringeSwordProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedCringeSwordProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedCringeSwordProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedCringeSwordProjectile>();
					}
					break;
				case 4:
					if (value is SpawnedFireFieldProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedFireFieldProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedFireFieldProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedFireFieldProjectile>();
					}
					break;
				case 5:
					if (value is SpawnedHeroSwordProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedHeroSwordProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedHeroSwordProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedHeroSwordProjectile>();
					}
					break;
				case 6:
					if (value is SpawnedRocketProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedRocketProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedRocketProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedRocketProjectile>();
					}
					break;
				case 7:
					if (value is SpawnedShotgunProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedShotgunProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedShotgunProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedShotgunProjectile>();
					}
					break;
				case 8:
					if (value is SpawnedDexecutionerProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedDexecutionerProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedDexecutionerProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedDexecutionerProjectile>();
					}
					break;
				case 9:
					if (value is SpawnedRevolverProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedRevolverProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedRevolverProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedRevolverProjectile>();
					}
					break;
				case 10:
					if (value is SpawnedSniperProjectile)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<SpawnedSniperProjectile>(ref Unsafe.As<AbstractSpawnedProjectile, SpawnedSniperProjectile>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<SpawnedSniperProjectile>();
					}
					break;
				default:
					MemoryPackSerializationException.ThrowInvalidTag(num, typeof(AbstractSpawnedProjectile));
					break;
				}
			}
		}

		public QuantizedVector3 Position { get; set; } = new QuantizedVector3();

		public uint Id { get; set; }

		public uint OwnerId { get; set; }

		public int Weapon { get; set; }

		public QuantizedVector3 Rotation { get; set; } = new QuantizedVector3();

		static AbstractSpawnedProjectile()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<AbstractSpawnedProjectile>())
			{
				MemoryPackFormatterProvider.Register<AbstractSpawnedProjectile>((MemoryPackFormatter<AbstractSpawnedProjectile>)(object)new AbstractSpawnedProjectileFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<AbstractSpawnedProjectile[]>())
			{
				MemoryPackFormatterProvider.Register<AbstractSpawnedProjectile[]>((MemoryPackFormatter<AbstractSpawnedProjectile[]>)(object)new ArrayFormatter<AbstractSpawnedProjectile>());
			}
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedProjectile : AbstractSpawnedProjectile, IMemoryPackable<SpawnedProjectile>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class SpawnedProjectileFormatter : MemoryPackFormatter<SpawnedProjectile>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedProjectile value)
			{
				SpawnedProjectile.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedProjectile value)
			{
				SpawnedProjectile.Deserialize(ref reader, ref value);
			}
		}

		static SpawnedProjectile()
		{
			RegisterFormatter();
		}

		[Preserve]
		public new static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedProjectile>())
			{
				MemoryPackFormatterProvider.Register<SpawnedProjectile>((MemoryPackFormatter<SpawnedProjectile>)(object)new SpawnedProjectileFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedProjectile[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedProjectile[]>((MemoryPackFormatter<SpawnedProjectile[]>)(object)new ArrayFormatter<SpawnedProjectile>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedProjectile? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)5);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
			uint id = value.Id;
			uint ownerId = value.OwnerId;
			int weapon = value.Weapon;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
			QuantizedVector3 rotation = value.Rotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref rotation);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedProjectile? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			QuantizedVector3 position;
			uint id = default(uint);
			uint ownerId = default(uint);
			int weapon = default(int);
			QuantizedVector3 rotation;
			if (b == 5)
			{
				if (value != null)
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
					goto IL_0122;
				}
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
				rotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
			}
			else
			{
				if (b > 5)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedProjectile), (byte)5, b);
					return;
				}
				if (value == null)
				{
					position = null;
					id = 0u;
					ownerId = 0u;
					weapon = 0;
					rotation = null;
				}
				else
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
									_ = 5;
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0122;
				}
			}
			value = new SpawnedProjectile
			{
				Position = position,
				Id = id,
				OwnerId = ownerId,
				Weapon = weapon,
				Rotation = rotation
			};
			return;
			IL_0122:
			value.Position = position;
			value.Id = id;
			value.OwnerId = ownerId;
			value.Weapon = weapon;
			value.Rotation = rotation;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedShotgunProjectile : AbstractSpawnedProjectile, IMemoryPackable<SpawnedShotgunProjectile>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class SpawnedShotgunProjectileFormatter : MemoryPackFormatter<SpawnedShotgunProjectile>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedShotgunProjectile value)
			{
				SpawnedShotgunProjectile.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedShotgunProjectile value)
			{
				SpawnedShotgunProjectile.Deserialize(ref reader, ref value);
			}
		}

		public QuantizedVector3 MuzzlePosition { get; set; } = new QuantizedVector3();

		public QuantizedVector3 MuzzleRotation { get; set; } = new QuantizedVector3();

		static SpawnedShotgunProjectile()
		{
			RegisterFormatter();
		}

		[Preserve]
		public new static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedShotgunProjectile>())
			{
				MemoryPackFormatterProvider.Register<SpawnedShotgunProjectile>((MemoryPackFormatter<SpawnedShotgunProjectile>)(object)new SpawnedShotgunProjectileFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedShotgunProjectile[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedShotgunProjectile[]>((MemoryPackFormatter<SpawnedShotgunProjectile[]>)(object)new ArrayFormatter<SpawnedShotgunProjectile>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedShotgunProjectile? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)7);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
			uint id = value.Id;
			uint ownerId = value.OwnerId;
			int weapon = value.Weapon;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
			QuantizedVector3 rotation = value.Rotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref rotation);
			QuantizedVector3 muzzlePosition = value.MuzzlePosition;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref muzzlePosition);
			QuantizedVector3 muzzleRotation = value.MuzzleRotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref muzzleRotation);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedShotgunProjectile? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			QuantizedVector3 position;
			uint id = default(uint);
			uint ownerId = default(uint);
			int weapon = default(int);
			QuantizedVector3 rotation;
			QuantizedVector3 muzzlePosition;
			QuantizedVector3 muzzleRotation;
			if (b == 7)
			{
				if (value != null)
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					muzzlePosition = value.MuzzlePosition;
					muzzleRotation = value.MuzzleRotation;
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref muzzlePosition);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref muzzleRotation);
					goto IL_0187;
				}
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
				rotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				muzzlePosition = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				muzzleRotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
			}
			else
			{
				if (b > 7)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedShotgunProjectile), (byte)7, b);
					return;
				}
				if (value == null)
				{
					position = null;
					id = 0u;
					ownerId = 0u;
					weapon = 0;
					rotation = null;
					muzzlePosition = null;
					muzzleRotation = null;
				}
				else
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					muzzlePosition = value.MuzzlePosition;
					muzzleRotation = value.MuzzleRotation;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
									if (b != 5)
									{
										((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref muzzlePosition);
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref muzzleRotation);
											_ = 7;
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0187;
				}
			}
			value = new SpawnedShotgunProjectile
			{
				Position = position,
				Id = id,
				OwnerId = ownerId,
				Weapon = weapon,
				Rotation = rotation,
				MuzzlePosition = muzzlePosition,
				MuzzleRotation = muzzleRotation
			};
			return;
			IL_0187:
			value.Position = position;
			value.Id = id;
			value.OwnerId = ownerId;
			value.Weapon = weapon;
			value.Rotation = rotation;
			value.MuzzlePosition = muzzlePosition;
			value.MuzzleRotation = muzzleRotation;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedAxeProjectile : AbstractSpawnedProjectile, IMemoryPackable<SpawnedAxeProjectile>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class SpawnedAxeProjectileFormatter : MemoryPackFormatter<SpawnedAxeProjectile>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedAxeProjectile value)
			{
				SpawnedAxeProjectile.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedAxeProjectile value)
			{
				SpawnedAxeProjectile.Deserialize(ref reader, ref value);
			}
		}

		public QuantizedVector3 StartPosition { get; set; } = new QuantizedVector3();

		public QuantizedVector3 DesiredPosition { get; set; } = new QuantizedVector3();

		static SpawnedAxeProjectile()
		{
			RegisterFormatter();
		}

		[Preserve]
		public new static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedAxeProjectile>())
			{
				MemoryPackFormatterProvider.Register<SpawnedAxeProjectile>((MemoryPackFormatter<SpawnedAxeProjectile>)(object)new SpawnedAxeProjectileFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedAxeProjectile[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedAxeProjectile[]>((MemoryPackFormatter<SpawnedAxeProjectile[]>)(object)new ArrayFormatter<SpawnedAxeProjectile>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedAxeProjectile? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)7);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
			uint id = value.Id;
			uint ownerId = value.OwnerId;
			int weapon = value.Weapon;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
			QuantizedVector3 rotation = value.Rotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref rotation);
			QuantizedVector3 startPosition = value.StartPosition;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref startPosition);
			QuantizedVector3 desiredPosition = value.DesiredPosition;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref desiredPosition);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedAxeProjectile? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			QuantizedVector3 position;
			uint id = default(uint);
			uint ownerId = default(uint);
			int weapon = default(int);
			QuantizedVector3 rotation;
			QuantizedVector3 startPosition;
			QuantizedVector3 desiredPosition;
			if (b == 7)
			{
				if (value != null)
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					startPosition = value.StartPosition;
					desiredPosition = value.DesiredPosition;
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref startPosition);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref desiredPosition);
					goto IL_0187;
				}
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
				rotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				startPosition = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				desiredPosition = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
			}
			else
			{
				if (b > 7)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedAxeProjectile), (byte)7, b);
					return;
				}
				if (value == null)
				{
					position = null;
					id = 0u;
					ownerId = 0u;
					weapon = 0;
					rotation = null;
					startPosition = null;
					desiredPosition = null;
				}
				else
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					startPosition = value.StartPosition;
					desiredPosition = value.DesiredPosition;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
									if (b != 5)
									{
										((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref startPosition);
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref desiredPosition);
											_ = 7;
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0187;
				}
			}
			value = new SpawnedAxeProjectile
			{
				Position = position,
				Id = id,
				OwnerId = ownerId,
				Weapon = weapon,
				Rotation = rotation,
				StartPosition = startPosition,
				DesiredPosition = desiredPosition
			};
			return;
			IL_0187:
			value.Position = position;
			value.Id = id;
			value.OwnerId = ownerId;
			value.Weapon = weapon;
			value.Rotation = rotation;
			value.StartPosition = startPosition;
			value.DesiredPosition = desiredPosition;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedBlackHoleProjectile : AbstractSpawnedProjectile, IMemoryPackable<SpawnedBlackHoleProjectile>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class SpawnedBlackHoleProjectileFormatter : MemoryPackFormatter<SpawnedBlackHoleProjectile>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedBlackHoleProjectile value)
			{
				SpawnedBlackHoleProjectile.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedBlackHoleProjectile value)
			{
				SpawnedBlackHoleProjectile.Deserialize(ref reader, ref value);
			}
		}

		public QuantizedVector3 StartPosition { get; set; } = new QuantizedVector3();

		public QuantizedVector3 DesiredPosition { get; set; } = new QuantizedVector3();

		public QuantizedVector3 StartScaleSize { get; set; } = new QuantizedVector3();

		static SpawnedBlackHoleProjectile()
		{
			RegisterFormatter();
		}

		[Preserve]
		public new static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedBlackHoleProjectile>())
			{
				MemoryPackFormatterProvider.Register<SpawnedBlackHoleProjectile>((MemoryPackFormatter<SpawnedBlackHoleProjectile>)(object)new SpawnedBlackHoleProjectileFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedBlackHoleProjectile[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedBlackHoleProjectile[]>((MemoryPackFormatter<SpawnedBlackHoleProjectile[]>)(object)new ArrayFormatter<SpawnedBlackHoleProjectile>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedBlackHoleProjectile? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)8);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
			uint id = value.Id;
			uint ownerId = value.OwnerId;
			int weapon = value.Weapon;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
			QuantizedVector3 rotation = value.Rotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref rotation);
			QuantizedVector3 startPosition = value.StartPosition;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref startPosition);
			QuantizedVector3 desiredPosition = value.DesiredPosition;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref desiredPosition);
			QuantizedVector3 startScaleSize = value.StartScaleSize;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref startScaleSize);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedBlackHoleProjectile? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			QuantizedVector3 position;
			uint id = default(uint);
			uint ownerId = default(uint);
			int weapon = default(int);
			QuantizedVector3 rotation;
			QuantizedVector3 startPosition;
			QuantizedVector3 desiredPosition;
			QuantizedVector3 startScaleSize;
			if (b == 8)
			{
				if (value != null)
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					startPosition = value.StartPosition;
					desiredPosition = value.DesiredPosition;
					startScaleSize = value.StartScaleSize;
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref startPosition);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref desiredPosition);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref startScaleSize);
					goto IL_01b8;
				}
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
				rotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				startPosition = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				desiredPosition = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				startScaleSize = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
			}
			else
			{
				if (b > 8)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedBlackHoleProjectile), (byte)8, b);
					return;
				}
				if (value == null)
				{
					position = null;
					id = 0u;
					ownerId = 0u;
					weapon = 0;
					rotation = null;
					startPosition = null;
					desiredPosition = null;
					startScaleSize = null;
				}
				else
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					startPosition = value.StartPosition;
					desiredPosition = value.DesiredPosition;
					startScaleSize = value.StartScaleSize;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
									if (b != 5)
									{
										((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref startPosition);
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref desiredPosition);
											if (b != 7)
											{
												((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref startScaleSize);
												_ = 8;
											}
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_01b8;
				}
			}
			value = new SpawnedBlackHoleProjectile
			{
				Position = position,
				Id = id,
				OwnerId = ownerId,
				Weapon = weapon,
				Rotation = rotation,
				StartPosition = startPosition,
				DesiredPosition = desiredPosition,
				StartScaleSize = startScaleSize
			};
			return;
			IL_01b8:
			value.Position = position;
			value.Id = id;
			value.OwnerId = ownerId;
			value.Weapon = weapon;
			value.Rotation = rotation;
			value.StartPosition = startPosition;
			value.DesiredPosition = desiredPosition;
			value.StartScaleSize = startScaleSize;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedCringeSwordProjectile : AbstractSpawnedProjectile, IMemoryPackable<SpawnedCringeSwordProjectile>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class SpawnedCringeSwordProjectileFormatter : MemoryPackFormatter<SpawnedCringeSwordProjectile>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedCringeSwordProjectile value)
			{
				SpawnedCringeSwordProjectile.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedCringeSwordProjectile value)
			{
				SpawnedCringeSwordProjectile.Deserialize(ref reader, ref value);
			}
		}

		public QuantizedVector3 MovingProjectilePosition { get; set; } = new QuantizedVector3();

		public QuantizedVector4 MovingProjectileRotation { get; set; } = new QuantizedVector4();

		static SpawnedCringeSwordProjectile()
		{
			RegisterFormatter();
		}

		[Preserve]
		public new static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedCringeSwordProjectile>())
			{
				MemoryPackFormatterProvider.Register<SpawnedCringeSwordProjectile>((MemoryPackFormatter<SpawnedCringeSwordProjectile>)(object)new SpawnedCringeSwordProjectileFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedCringeSwordProjectile[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedCringeSwordProjectile[]>((MemoryPackFormatter<SpawnedCringeSwordProjectile[]>)(object)new ArrayFormatter<SpawnedCringeSwordProjectile>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedCringeSwordProjectile? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)7);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
			uint id = value.Id;
			uint ownerId = value.OwnerId;
			int weapon = value.Weapon;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
			QuantizedVector3 rotation = value.Rotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref rotation);
			QuantizedVector3 movingProjectilePosition = value.MovingProjectilePosition;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref movingProjectilePosition);
			QuantizedVector4 movingProjectileRotation = value.MovingProjectileRotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector4>>(ref writer).WritePackable<QuantizedVector4>(ref movingProjectileRotation);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedCringeSwordProjectile? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			QuantizedVector3 position;
			uint id = default(uint);
			uint ownerId = default(uint);
			int weapon = default(int);
			QuantizedVector3 rotation;
			QuantizedVector3 movingProjectilePosition;
			QuantizedVector4 movingProjectileRotation;
			if (b == 7)
			{
				if (value != null)
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					movingProjectilePosition = value.MovingProjectilePosition;
					movingProjectileRotation = value.MovingProjectileRotation;
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref movingProjectilePosition);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector4>(ref movingProjectileRotation);
					goto IL_0187;
				}
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
				rotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				movingProjectilePosition = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				movingProjectileRotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector4>();
			}
			else
			{
				if (b > 7)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedCringeSwordProjectile), (byte)7, b);
					return;
				}
				if (value == null)
				{
					position = null;
					id = 0u;
					ownerId = 0u;
					weapon = 0;
					rotation = null;
					movingProjectilePosition = null;
					movingProjectileRotation = null;
				}
				else
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					movingProjectilePosition = value.MovingProjectilePosition;
					movingProjectileRotation = value.MovingProjectileRotation;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
									if (b != 5)
									{
										((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref movingProjectilePosition);
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector4>(ref movingProjectileRotation);
											_ = 7;
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0187;
				}
			}
			value = new SpawnedCringeSwordProjectile
			{
				Position = position,
				Id = id,
				OwnerId = ownerId,
				Weapon = weapon,
				Rotation = rotation,
				MovingProjectilePosition = movingProjectilePosition,
				MovingProjectileRotation = movingProjectileRotation
			};
			return;
			IL_0187:
			value.Position = position;
			value.Id = id;
			value.OwnerId = ownerId;
			value.Weapon = weapon;
			value.Rotation = rotation;
			value.MovingProjectilePosition = movingProjectilePosition;
			value.MovingProjectileRotation = movingProjectileRotation;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedFireFieldProjectile : AbstractSpawnedProjectile, IMemoryPackable<SpawnedFireFieldProjectile>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class SpawnedFireFieldProjectileFormatter : MemoryPackFormatter<SpawnedFireFieldProjectile>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedFireFieldProjectile value)
			{
				SpawnedFireFieldProjectile.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedFireFieldProjectile value)
			{
				SpawnedFireFieldProjectile.Deserialize(ref reader, ref value);
			}
		}

		public float ExpirationTime { get; set; }

		static SpawnedFireFieldProjectile()
		{
			RegisterFormatter();
		}

		[Preserve]
		public new static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedFireFieldProjectile>())
			{
				MemoryPackFormatterProvider.Register<SpawnedFireFieldProjectile>((MemoryPackFormatter<SpawnedFireFieldProjectile>)(object)new SpawnedFireFieldProjectileFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedFireFieldProjectile[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedFireFieldProjectile[]>((MemoryPackFormatter<SpawnedFireFieldProjectile[]>)(object)new ArrayFormatter<SpawnedFireFieldProjectile>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedFireFieldProjectile? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)6);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
			uint id = value.Id;
			uint ownerId = value.OwnerId;
			int weapon = value.Weapon;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
			QuantizedVector3 rotation = value.Rotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref rotation);
			float expirationTime = value.ExpirationTime;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<float>>(ref writer).WriteUnmanaged<float>(ref expirationTime);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedFireFieldProjectile? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			QuantizedVector3 position;
			uint id = default(uint);
			uint ownerId = default(uint);
			int weapon = default(int);
			QuantizedVector3 rotation;
			float expirationTime = default(float);
			if (b == 6)
			{
				if (value != null)
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					expirationTime = value.ExpirationTime;
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref expirationTime);
					goto IL_015a;
				}
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
				rotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref expirationTime);
			}
			else
			{
				if (b > 6)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedFireFieldProjectile), (byte)6, b);
					return;
				}
				if (value == null)
				{
					position = null;
					id = 0u;
					ownerId = 0u;
					weapon = 0;
					rotation = null;
					expirationTime = 0f;
				}
				else
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					expirationTime = value.ExpirationTime;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
									if (b != 5)
									{
										((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref expirationTime);
										_ = 6;
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_015a;
				}
			}
			value = new SpawnedFireFieldProjectile
			{
				Position = position,
				Id = id,
				OwnerId = ownerId,
				Weapon = weapon,
				Rotation = rotation,
				ExpirationTime = expirationTime
			};
			return;
			IL_015a:
			value.Position = position;
			value.Id = id;
			value.OwnerId = ownerId;
			value.Weapon = weapon;
			value.Rotation = rotation;
			value.ExpirationTime = expirationTime;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedHeroSwordProjectile : AbstractSpawnedProjectile, IMemoryPackable<SpawnedHeroSwordProjectile>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class SpawnedHeroSwordProjectileFormatter : MemoryPackFormatter<SpawnedHeroSwordProjectile>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedHeroSwordProjectile value)
			{
				SpawnedHeroSwordProjectile.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedHeroSwordProjectile value)
			{
				SpawnedHeroSwordProjectile.Deserialize(ref reader, ref value);
			}
		}

		public QuantizedVector3 MovingProjectilePosition { get; set; } = new QuantizedVector3();

		public QuantizedVector4 MovingProjectileRotation { get; set; } = new QuantizedVector4();

		static SpawnedHeroSwordProjectile()
		{
			RegisterFormatter();
		}

		[Preserve]
		public new static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedHeroSwordProjectile>())
			{
				MemoryPackFormatterProvider.Register<SpawnedHeroSwordProjectile>((MemoryPackFormatter<SpawnedHeroSwordProjectile>)(object)new SpawnedHeroSwordProjectileFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedHeroSwordProjectile[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedHeroSwordProjectile[]>((MemoryPackFormatter<SpawnedHeroSwordProjectile[]>)(object)new ArrayFormatter<SpawnedHeroSwordProjectile>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedHeroSwordProjectile? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)7);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
			uint id = value.Id;
			uint ownerId = value.OwnerId;
			int weapon = value.Weapon;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
			QuantizedVector3 rotation = value.Rotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref rotation);
			QuantizedVector3 movingProjectilePosition = value.MovingProjectilePosition;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref movingProjectilePosition);
			QuantizedVector4 movingProjectileRotation = value.MovingProjectileRotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector4>>(ref writer).WritePackable<QuantizedVector4>(ref movingProjectileRotation);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedHeroSwordProjectile? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			QuantizedVector3 position;
			uint id = default(uint);
			uint ownerId = default(uint);
			int weapon = default(int);
			QuantizedVector3 rotation;
			QuantizedVector3 movingProjectilePosition;
			QuantizedVector4 movingProjectileRotation;
			if (b == 7)
			{
				if (value != null)
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					movingProjectilePosition = value.MovingProjectilePosition;
					movingProjectileRotation = value.MovingProjectileRotation;
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref movingProjectilePosition);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector4>(ref movingProjectileRotation);
					goto IL_0187;
				}
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
				rotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				movingProjectilePosition = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				movingProjectileRotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector4>();
			}
			else
			{
				if (b > 7)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedHeroSwordProjectile), (byte)7, b);
					return;
				}
				if (value == null)
				{
					position = null;
					id = 0u;
					ownerId = 0u;
					weapon = 0;
					rotation = null;
					movingProjectilePosition = null;
					movingProjectileRotation = null;
				}
				else
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					movingProjectilePosition = value.MovingProjectilePosition;
					movingProjectileRotation = value.MovingProjectileRotation;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
									if (b != 5)
									{
										((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref movingProjectilePosition);
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector4>(ref movingProjectileRotation);
											_ = 7;
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0187;
				}
			}
			value = new SpawnedHeroSwordProjectile
			{
				Position = position,
				Id = id,
				OwnerId = ownerId,
				Weapon = weapon,
				Rotation = rotation,
				MovingProjectilePosition = movingProjectilePosition,
				MovingProjectileRotation = movingProjectileRotation
			};
			return;
			IL_0187:
			value.Position = position;
			value.Id = id;
			value.OwnerId = ownerId;
			value.Weapon = weapon;
			value.Rotation = rotation;
			value.MovingProjectilePosition = movingProjectilePosition;
			value.MovingProjectileRotation = movingProjectileRotation;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedRocketProjectile : AbstractSpawnedProjectile, IMemoryPackable<SpawnedRocketProjectile>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class SpawnedRocketProjectileFormatter : MemoryPackFormatter<SpawnedRocketProjectile>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedRocketProjectile value)
			{
				SpawnedRocketProjectile.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedRocketProjectile value)
			{
				SpawnedRocketProjectile.Deserialize(ref reader, ref value);
			}
		}

		public QuantizedVector3 RocketPosition { get; set; }

		public QuantizedVector3 RocketRotation { get; set; }

		static SpawnedRocketProjectile()
		{
			RegisterFormatter();
		}

		[Preserve]
		public new static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedRocketProjectile>())
			{
				MemoryPackFormatterProvider.Register<SpawnedRocketProjectile>((MemoryPackFormatter<SpawnedRocketProjectile>)(object)new SpawnedRocketProjectileFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedRocketProjectile[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedRocketProjectile[]>((MemoryPackFormatter<SpawnedRocketProjectile[]>)(object)new ArrayFormatter<SpawnedRocketProjectile>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedRocketProjectile? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)7);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
			uint id = value.Id;
			uint ownerId = value.OwnerId;
			int weapon = value.Weapon;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
			QuantizedVector3 rotation = value.Rotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref rotation);
			QuantizedVector3 rocketPosition = value.RocketPosition;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref rocketPosition);
			QuantizedVector3 rocketRotation = value.RocketRotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref rocketRotation);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedRocketProjectile? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			QuantizedVector3 position;
			uint id = default(uint);
			uint ownerId = default(uint);
			int weapon = default(int);
			QuantizedVector3 rotation;
			QuantizedVector3 rocketPosition;
			QuantizedVector3 rocketRotation;
			if (b == 7)
			{
				if (value != null)
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					rocketPosition = value.RocketPosition;
					rocketRotation = value.RocketRotation;
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rocketPosition);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rocketRotation);
					goto IL_0187;
				}
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
				rotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				rocketPosition = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				rocketRotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
			}
			else
			{
				if (b > 7)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedRocketProjectile), (byte)7, b);
					return;
				}
				if (value == null)
				{
					position = null;
					id = 0u;
					ownerId = 0u;
					weapon = 0;
					rotation = null;
					rocketPosition = null;
					rocketRotation = null;
				}
				else
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					rocketPosition = value.RocketPosition;
					rocketRotation = value.RocketRotation;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
									if (b != 5)
									{
										((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rocketPosition);
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rocketRotation);
											_ = 7;
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0187;
				}
			}
			value = new SpawnedRocketProjectile
			{
				Position = position,
				Id = id,
				OwnerId = ownerId,
				Weapon = weapon,
				Rotation = rotation,
				RocketPosition = rocketPosition,
				RocketRotation = rocketRotation
			};
			return;
			IL_0187:
			value.Position = position;
			value.Id = id;
			value.OwnerId = ownerId;
			value.Weapon = weapon;
			value.Rotation = rotation;
			value.RocketPosition = rocketPosition;
			value.RocketRotation = rocketRotation;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedDexecutionerProjectile : AbstractSpawnedProjectile, IMemoryPackable<SpawnedDexecutionerProjectile>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class SpawnedDexecutionerProjectileFormatter : MemoryPackFormatter<SpawnedDexecutionerProjectile>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedDexecutionerProjectile value)
			{
				SpawnedDexecutionerProjectile.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedDexecutionerProjectile value)
			{
				SpawnedDexecutionerProjectile.Deserialize(ref reader, ref value);
			}
		}

		public float ProjectileDistance { get; set; }

		public float ForwardOffset { get; set; }

		public float UpOffset { get; set; }

		public QuantizedVector3 AttackDir { get; set; }

		public float Chance { get; set; }

		public bool UseAudio { get; set; }

		static SpawnedDexecutionerProjectile()
		{
			RegisterFormatter();
		}

		[Preserve]
		public new static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedDexecutionerProjectile>())
			{
				MemoryPackFormatterProvider.Register<SpawnedDexecutionerProjectile>((MemoryPackFormatter<SpawnedDexecutionerProjectile>)(object)new SpawnedDexecutionerProjectileFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedDexecutionerProjectile[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedDexecutionerProjectile[]>((MemoryPackFormatter<SpawnedDexecutionerProjectile[]>)(object)new ArrayFormatter<SpawnedDexecutionerProjectile>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedDexecutionerProjectile? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)11);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
			uint id = value.Id;
			uint ownerId = value.OwnerId;
			int weapon = value.Weapon;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
			QuantizedVector3 rotation = value.Rotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref rotation);
			float projectileDistance = value.ProjectileDistance;
			float forwardOffset = value.ForwardOffset;
			float upOffset = value.UpOffset;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<float>>(ref writer).WriteUnmanaged<float, float, float>(ref projectileDistance, ref forwardOffset, ref upOffset);
			QuantizedVector3 attackDir = value.AttackDir;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref attackDir);
			float chance = value.Chance;
			bool useAudio = value.UseAudio;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<float>>(ref writer).WriteUnmanaged<float, bool>(ref chance, ref useAudio);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedDexecutionerProjectile? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			QuantizedVector3 position;
			uint id = default(uint);
			uint ownerId = default(uint);
			int weapon = default(int);
			QuantizedVector3 rotation;
			float projectileDistance = default(float);
			float forwardOffset = default(float);
			float upOffset = default(float);
			QuantizedVector3 attackDir;
			float chance = default(float);
			bool useAudio = default(bool);
			if (b == 11)
			{
				if (value != null)
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					projectileDistance = value.ProjectileDistance;
					forwardOffset = value.ForwardOffset;
					upOffset = value.UpOffset;
					attackDir = value.AttackDir;
					chance = value.Chance;
					useAudio = value.UseAudio;
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref projectileDistance);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref forwardOffset);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref upOffset);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref attackDir);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref chance);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref useAudio);
					goto IL_0252;
				}
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
				rotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<float, float, float>(ref projectileDistance, ref forwardOffset, ref upOffset);
				attackDir = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<float, bool>(ref chance, ref useAudio);
			}
			else
			{
				if (b > 11)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedDexecutionerProjectile), (byte)11, b);
					return;
				}
				if (value == null)
				{
					position = null;
					id = 0u;
					ownerId = 0u;
					weapon = 0;
					rotation = null;
					projectileDistance = 0f;
					forwardOffset = 0f;
					upOffset = 0f;
					attackDir = null;
					chance = 0f;
					useAudio = false;
				}
				else
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					projectileDistance = value.ProjectileDistance;
					forwardOffset = value.ForwardOffset;
					upOffset = value.UpOffset;
					attackDir = value.AttackDir;
					chance = value.Chance;
					useAudio = value.UseAudio;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
									if (b != 5)
									{
										((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref projectileDistance);
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref forwardOffset);
											if (b != 7)
											{
												((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref upOffset);
												if (b != 8)
												{
													((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref attackDir);
													if (b != 9)
													{
														((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref chance);
														if (b != 10)
														{
															((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref useAudio);
															_ = 11;
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0252;
				}
			}
			value = new SpawnedDexecutionerProjectile
			{
				Position = position,
				Id = id,
				OwnerId = ownerId,
				Weapon = weapon,
				Rotation = rotation,
				ProjectileDistance = projectileDistance,
				ForwardOffset = forwardOffset,
				UpOffset = upOffset,
				AttackDir = attackDir,
				Chance = chance,
				UseAudio = useAudio
			};
			return;
			IL_0252:
			value.Position = position;
			value.Id = id;
			value.OwnerId = ownerId;
			value.Weapon = weapon;
			value.Rotation = rotation;
			value.ProjectileDistance = projectileDistance;
			value.ForwardOffset = forwardOffset;
			value.UpOffset = upOffset;
			value.AttackDir = attackDir;
			value.Chance = chance;
			value.UseAudio = useAudio;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedRevolverProjectile : AbstractSpawnedProjectile, IMemoryPackable<SpawnedRevolverProjectile>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class SpawnedRevolverProjectileFormatter : MemoryPackFormatter<SpawnedRevolverProjectile>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedRevolverProjectile value)
			{
				SpawnedRevolverProjectile.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedRevolverProjectile value)
			{
				SpawnedRevolverProjectile.Deserialize(ref reader, ref value);
			}
		}

		public QuantizedVector3 MuzzlePosition { get; set; } = new QuantizedVector3();

		public QuantizedVector3 MuzzleRotation { get; set; } = new QuantizedVector3();

		static SpawnedRevolverProjectile()
		{
			RegisterFormatter();
		}

		[Preserve]
		public new static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedRevolverProjectile>())
			{
				MemoryPackFormatterProvider.Register<SpawnedRevolverProjectile>((MemoryPackFormatter<SpawnedRevolverProjectile>)(object)new SpawnedRevolverProjectileFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedRevolverProjectile[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedRevolverProjectile[]>((MemoryPackFormatter<SpawnedRevolverProjectile[]>)(object)new ArrayFormatter<SpawnedRevolverProjectile>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedRevolverProjectile? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)7);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
			uint id = value.Id;
			uint ownerId = value.OwnerId;
			int weapon = value.Weapon;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
			QuantizedVector3 rotation = value.Rotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref rotation);
			QuantizedVector3 muzzlePosition = value.MuzzlePosition;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref muzzlePosition);
			QuantizedVector3 muzzleRotation = value.MuzzleRotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref muzzleRotation);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedRevolverProjectile? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			QuantizedVector3 position;
			uint id = default(uint);
			uint ownerId = default(uint);
			int weapon = default(int);
			QuantizedVector3 rotation;
			QuantizedVector3 muzzlePosition;
			QuantizedVector3 muzzleRotation;
			if (b == 7)
			{
				if (value != null)
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					muzzlePosition = value.MuzzlePosition;
					muzzleRotation = value.MuzzleRotation;
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref muzzlePosition);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref muzzleRotation);
					goto IL_0187;
				}
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
				rotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				muzzlePosition = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				muzzleRotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
			}
			else
			{
				if (b > 7)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedRevolverProjectile), (byte)7, b);
					return;
				}
				if (value == null)
				{
					position = null;
					id = 0u;
					ownerId = 0u;
					weapon = 0;
					rotation = null;
					muzzlePosition = null;
					muzzleRotation = null;
				}
				else
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					muzzlePosition = value.MuzzlePosition;
					muzzleRotation = value.MuzzleRotation;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
									if (b != 5)
									{
										((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref muzzlePosition);
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref muzzleRotation);
											_ = 7;
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0187;
				}
			}
			value = new SpawnedRevolverProjectile
			{
				Position = position,
				Id = id,
				OwnerId = ownerId,
				Weapon = weapon,
				Rotation = rotation,
				MuzzlePosition = muzzlePosition,
				MuzzleRotation = muzzleRotation
			};
			return;
			IL_0187:
			value.Position = position;
			value.Id = id;
			value.OwnerId = ownerId;
			value.Weapon = weapon;
			value.Rotation = rotation;
			value.MuzzlePosition = muzzlePosition;
			value.MuzzleRotation = muzzleRotation;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedSniperProjectile : AbstractSpawnedProjectile, IMemoryPackable<SpawnedSniperProjectile>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class SpawnedSniperProjectileFormatter : MemoryPackFormatter<SpawnedSniperProjectile>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedSniperProjectile value)
			{
				SpawnedSniperProjectile.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedSniperProjectile value)
			{
				SpawnedSniperProjectile.Deserialize(ref reader, ref value);
			}
		}

		public QuantizedVector3 MuzzlePosition { get; set; } = new QuantizedVector3();

		public QuantizedVector3 MuzzleRotation { get; set; } = new QuantizedVector3();

		static SpawnedSniperProjectile()
		{
			RegisterFormatter();
		}

		[Preserve]
		public new static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedSniperProjectile>())
			{
				MemoryPackFormatterProvider.Register<SpawnedSniperProjectile>((MemoryPackFormatter<SpawnedSniperProjectile>)(object)new SpawnedSniperProjectileFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedSniperProjectile[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedSniperProjectile[]>((MemoryPackFormatter<SpawnedSniperProjectile[]>)(object)new ArrayFormatter<SpawnedSniperProjectile>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedSniperProjectile? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)7);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
			uint id = value.Id;
			uint ownerId = value.OwnerId;
			int weapon = value.Weapon;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
			QuantizedVector3 rotation = value.Rotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref rotation);
			QuantizedVector3 muzzlePosition = value.MuzzlePosition;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref muzzlePosition);
			QuantizedVector3 muzzleRotation = value.MuzzleRotation;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref muzzleRotation);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedSniperProjectile? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			QuantizedVector3 position;
			uint id = default(uint);
			uint ownerId = default(uint);
			int weapon = default(int);
			QuantizedVector3 rotation;
			QuantizedVector3 muzzlePosition;
			QuantizedVector3 muzzleRotation;
			if (b == 7)
			{
				if (value != null)
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					muzzlePosition = value.MuzzlePosition;
					muzzleRotation = value.MuzzleRotation;
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref muzzlePosition);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref muzzleRotation);
					goto IL_0187;
				}
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint, int>(ref id, ref ownerId, ref weapon);
				rotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				muzzlePosition = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				muzzleRotation = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
			}
			else
			{
				if (b > 7)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedSniperProjectile), (byte)7, b);
					return;
				}
				if (value == null)
				{
					position = null;
					id = 0u;
					ownerId = 0u;
					weapon = 0;
					rotation = null;
					muzzlePosition = null;
					muzzleRotation = null;
				}
				else
				{
					position = value.Position;
					id = value.Id;
					ownerId = value.OwnerId;
					weapon = value.Weapon;
					rotation = value.Rotation;
					muzzlePosition = value.MuzzlePosition;
					muzzleRotation = value.MuzzleRotation;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref id);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
								if (b != 4)
								{
									((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref rotation);
									if (b != 5)
									{
										((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref muzzlePosition);
										if (b != 6)
										{
											((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref muzzleRotation);
											_ = 7;
										}
									}
								}
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_0187;
				}
			}
			value = new SpawnedSniperProjectile
			{
				Position = position,
				Id = id,
				OwnerId = ownerId,
				Weapon = weapon,
				Rotation = rotation,
				MuzzlePosition = muzzlePosition,
				MuzzleRotation = muzzleRotation
			};
			return;
			IL_0187:
			value.Position = position;
			value.Id = id;
			value.OwnerId = ownerId;
			value.Weapon = weapon;
			value.Rotation = rotation;
			value.MuzzlePosition = muzzlePosition;
			value.MuzzleRotation = muzzleRotation;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class StartedSwarmEvent : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<StartedSwarmEvent>
	{
		[Preserve]
		private sealed class StartedSwarmEventFormatter : MemoryPackFormatter<StartedSwarmEvent>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StartedSwarmEvent value)
			{
				StartedSwarmEvent.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref StartedSwarmEvent value)
			{
				StartedSwarmEvent.Deserialize(ref reader, ref value);
			}
		}

		public float Duration;

		static StartedSwarmEvent()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<StartedSwarmEvent>())
			{
				MemoryPackFormatterProvider.Register<StartedSwarmEvent>((MemoryPackFormatter<StartedSwarmEvent>)(object)new StartedSwarmEventFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<StartedSwarmEvent[]>())
			{
				MemoryPackFormatterProvider.Register<StartedSwarmEvent[]>((MemoryPackFormatter<StartedSwarmEvent[]>)(object)new ArrayFormatter<StartedSwarmEvent>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StartedSwarmEvent? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
			}
			else
			{
				Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<float>>(ref writer).WriteUnmanagedWithObjectHeader<float>((byte)1, ref value.Duration);
			}
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref StartedSwarmEvent? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			float duration = default(float);
			if (b == 1)
			{
				if (value != null)
				{
					duration = value.Duration;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref duration);
					goto IL_006f;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref duration);
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(StartedSwarmEvent), (byte)1, b);
					return;
				}
				duration = ((value != null) ? value.Duration : 0f);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref duration);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006f;
				}
			}
			value = new StartedSwarmEvent
			{
				Duration = duration
			};
			return;
			IL_006f:
			value.Duration = duration;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class StartingChargingPylon : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<StartingChargingPylon>
	{
		[Preserve]
		private sealed class StartingChargingPylonFormatter : MemoryPackFormatter<StartingChargingPylon>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StartingChargingPylon value)
			{
				StartingChargingPylon.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref StartingChargingPylon value)
			{
				StartingChargingPylon.Deserialize(ref reader, ref value);
			}
		}

		public uint PylonNetplayId;

		public uint PlayerChargingId;

		static StartingChargingPylon()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<StartingChargingPylon>())
			{
				MemoryPackFormatterProvider.Register<StartingChargingPylon>((MemoryPackFormatter<StartingChargingPylon>)(object)new StartingChargingPylonFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<StartingChargingPylon[]>())
			{
				MemoryPackFormatterProvider.Register<StartingChargingPylon[]>((MemoryPackFormatter<StartingChargingPylon[]>)(object)new ArrayFormatter<StartingChargingPylon>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StartingChargingPylon? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
			}
			else
			{
				Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref value.PylonNetplayId, ref value.PlayerChargingId);
			}
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref StartingChargingPylon? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint pylonNetplayId = default(uint);
			uint playerChargingId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					pylonNetplayId = value.PylonNetplayId;
					playerChargingId = value.PlayerChargingId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref pylonNetplayId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerChargingId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref pylonNetplayId, ref playerChargingId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(StartingChargingPylon), (byte)2, b);
					return;
				}
				if (value == null)
				{
					pylonNetplayId = 0u;
					playerChargingId = 0u;
				}
				else
				{
					pylonNetplayId = value.PylonNetplayId;
					playerChargingId = value.PlayerChargingId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref pylonNetplayId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerChargingId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new StartingChargingPylon
			{
				PylonNetplayId = pylonNetplayId,
				PlayerChargingId = playerChargingId
			};
			return;
			IL_0096:
			value.PylonNetplayId = pylonNetplayId;
			value.PlayerChargingId = playerChargingId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class StartingChargingShrine : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<StartingChargingShrine>
	{
		[Preserve]
		private sealed class StartingChargingShrineFormatter : MemoryPackFormatter<StartingChargingShrine>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StartingChargingShrine value)
			{
				StartingChargingShrine.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref StartingChargingShrine value)
			{
				StartingChargingShrine.Deserialize(ref reader, ref value);
			}
		}

		public uint ShrineNetplayId;

		public uint PlayerChargingId;

		static StartingChargingShrine()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<StartingChargingShrine>())
			{
				MemoryPackFormatterProvider.Register<StartingChargingShrine>((MemoryPackFormatter<StartingChargingShrine>)(object)new StartingChargingShrineFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<StartingChargingShrine[]>())
			{
				MemoryPackFormatterProvider.Register<StartingChargingShrine[]>((MemoryPackFormatter<StartingChargingShrine[]>)(object)new ArrayFormatter<StartingChargingShrine>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StartingChargingShrine? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
			}
			else
			{
				Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref value.ShrineNetplayId, ref value.PlayerChargingId);
			}
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref StartingChargingShrine? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint shrineNetplayId = default(uint);
			uint playerChargingId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					shrineNetplayId = value.ShrineNetplayId;
					playerChargingId = value.PlayerChargingId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref shrineNetplayId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerChargingId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref shrineNetplayId, ref playerChargingId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(StartingChargingShrine), (byte)2, b);
					return;
				}
				if (value == null)
				{
					shrineNetplayId = 0u;
					playerChargingId = 0u;
				}
				else
				{
					shrineNetplayId = value.ShrineNetplayId;
					playerChargingId = value.PlayerChargingId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref shrineNetplayId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerChargingId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new StartingChargingShrine
			{
				ShrineNetplayId = shrineNetplayId,
				PlayerChargingId = playerChargingId
			};
			return;
			IL_0096:
			value.ShrineNetplayId = shrineNetplayId;
			value.PlayerChargingId = playerChargingId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class StoppingChargingPylon : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<StoppingChargingPylon>
	{
		[Preserve]
		private sealed class StoppingChargingPylonFormatter : MemoryPackFormatter<StoppingChargingPylon>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StoppingChargingPylon value)
			{
				StoppingChargingPylon.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref StoppingChargingPylon value)
			{
				StoppingChargingPylon.Deserialize(ref reader, ref value);
			}
		}

		public uint PylonNetplayId;

		public uint PlayerChargingId;

		static StoppingChargingPylon()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<StoppingChargingPylon>())
			{
				MemoryPackFormatterProvider.Register<StoppingChargingPylon>((MemoryPackFormatter<StoppingChargingPylon>)(object)new StoppingChargingPylonFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<StoppingChargingPylon[]>())
			{
				MemoryPackFormatterProvider.Register<StoppingChargingPylon[]>((MemoryPackFormatter<StoppingChargingPylon[]>)(object)new ArrayFormatter<StoppingChargingPylon>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StoppingChargingPylon? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
			}
			else
			{
				Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref value.PylonNetplayId, ref value.PlayerChargingId);
			}
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref StoppingChargingPylon? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint pylonNetplayId = default(uint);
			uint playerChargingId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					pylonNetplayId = value.PylonNetplayId;
					playerChargingId = value.PlayerChargingId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref pylonNetplayId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerChargingId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref pylonNetplayId, ref playerChargingId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(StoppingChargingPylon), (byte)2, b);
					return;
				}
				if (value == null)
				{
					pylonNetplayId = 0u;
					playerChargingId = 0u;
				}
				else
				{
					pylonNetplayId = value.PylonNetplayId;
					playerChargingId = value.PlayerChargingId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref pylonNetplayId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerChargingId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new StoppingChargingPylon
			{
				PylonNetplayId = pylonNetplayId,
				PlayerChargingId = playerChargingId
			};
			return;
			IL_0096:
			value.PylonNetplayId = pylonNetplayId;
			value.PlayerChargingId = playerChargingId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class StoppingChargingShrine : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<StoppingChargingShrine>
	{
		[Preserve]
		private sealed class StoppingChargingShrineFormatter : MemoryPackFormatter<StoppingChargingShrine>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StoppingChargingShrine value)
			{
				StoppingChargingShrine.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref StoppingChargingShrine value)
			{
				StoppingChargingShrine.Deserialize(ref reader, ref value);
			}
		}

		public uint ShrineNetplayId;

		public uint PlayerChargingId;

		static StoppingChargingShrine()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<StoppingChargingShrine>())
			{
				MemoryPackFormatterProvider.Register<StoppingChargingShrine>((MemoryPackFormatter<StoppingChargingShrine>)(object)new StoppingChargingShrineFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<StoppingChargingShrine[]>())
			{
				MemoryPackFormatterProvider.Register<StoppingChargingShrine[]>((MemoryPackFormatter<StoppingChargingShrine[]>)(object)new ArrayFormatter<StoppingChargingShrine>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StoppingChargingShrine? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
			}
			else
			{
				Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref value.ShrineNetplayId, ref value.PlayerChargingId);
			}
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref StoppingChargingShrine? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint shrineNetplayId = default(uint);
			uint playerChargingId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					shrineNetplayId = value.ShrineNetplayId;
					playerChargingId = value.PlayerChargingId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref shrineNetplayId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerChargingId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref shrineNetplayId, ref playerChargingId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(StoppingChargingShrine), (byte)2, b);
					return;
				}
				if (value == null)
				{
					shrineNetplayId = 0u;
					playerChargingId = 0u;
				}
				else
				{
					shrineNetplayId = value.ShrineNetplayId;
					playerChargingId = value.PlayerChargingId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref shrineNetplayId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerChargingId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new StoppingChargingShrine
			{
				ShrineNetplayId = shrineNetplayId,
				PlayerChargingId = playerChargingId
			};
			return;
			IL_0096:
			value.ShrineNetplayId = shrineNetplayId;
			value.PlayerChargingId = playerChargingId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class StormStarted : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<StormStarted>
	{
		[Preserve]
		private sealed class StormStartedFormatter : MemoryPackFormatter<StormStarted>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StormStarted value)
			{
				StormStarted.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref StormStarted value)
			{
				StormStarted.Deserialize(ref reader, ref value);
			}
		}

		public float StormOverAtTime { get; set; }

		static StormStarted()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<StormStarted>())
			{
				MemoryPackFormatterProvider.Register<StormStarted>((MemoryPackFormatter<StormStarted>)(object)new StormStartedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<StormStarted[]>())
			{
				MemoryPackFormatterProvider.Register<StormStarted[]>((MemoryPackFormatter<StormStarted[]>)(object)new ArrayFormatter<StormStarted>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StormStarted? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			float stormOverAtTime = value.StormOverAtTime;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<float>>(ref writer).WriteUnmanagedWithObjectHeader<float>((byte)1, ref stormOverAtTime);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref StormStarted? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			float stormOverAtTime = default(float);
			if (b == 1)
			{
				if (value != null)
				{
					stormOverAtTime = value.StormOverAtTime;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref stormOverAtTime);
					goto IL_006f;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref stormOverAtTime);
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(StormStarted), (byte)1, b);
					return;
				}
				stormOverAtTime = ((value != null) ? value.StormOverAtTime : 0f);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref stormOverAtTime);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006f;
				}
			}
			value = new StormStarted
			{
				StormOverAtTime = stormOverAtTime
			};
			return;
			IL_006f:
			value.StormOverAtTime = stormOverAtTime;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class StormStopped : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<StormStopped>
	{
		[Preserve]
		private sealed class StormStoppedFormatter : MemoryPackFormatter<StormStopped>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StormStopped value)
			{
				StormStopped.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref StormStopped value)
			{
				StormStopped.Deserialize(ref reader, ref value);
			}
		}

		static StormStopped()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<StormStopped>())
			{
				MemoryPackFormatterProvider.Register<StormStopped>((MemoryPackFormatter<StormStopped>)(object)new StormStoppedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<StormStopped[]>())
			{
				MemoryPackFormatterProvider.Register<StormStopped[]>((MemoryPackFormatter<StormStopped[]>)(object)new ArrayFormatter<StormStopped>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StormStopped? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
			}
			else
			{
				writer.WriteObjectHeader((byte)0);
			}
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref StormStopped? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			if (b == 0)
			{
				if (value != null)
				{
					return;
				}
			}
			else
			{
				if (b > 0)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(StormStopped), (byte)0, b);
					return;
				}
				_ = value;
				if (value != null)
				{
					return;
				}
			}
			value = new StormStopped();
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class TomeAdded : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<TomeAdded>
	{
		[Preserve]
		private sealed class TomeAddedFormatter : MemoryPackFormatter<TomeAdded>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TomeAdded value)
			{
				TomeAdded.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref TomeAdded value)
			{
				TomeAdded.Deserialize(ref reader, ref value);
			}
		}

		public int Tome { get; set; }

		public uint OwnerId { get; set; }

		public List<StatModifierModel> Upgrades { get; set; }

		public int Rarity { get; set; }

		static TomeAdded()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<TomeAdded>())
			{
				MemoryPackFormatterProvider.Register<TomeAdded>((MemoryPackFormatter<TomeAdded>)(object)new TomeAddedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<TomeAdded[]>())
			{
				MemoryPackFormatterProvider.Register<TomeAdded[]>((MemoryPackFormatter<TomeAdded[]>)(object)new ArrayFormatter<TomeAdded>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<List<StatModifierModel>>())
			{
				MemoryPackFormatterProvider.Register<List<StatModifierModel>>((MemoryPackFormatter<List<StatModifierModel>>)(object)new ListFormatter<StatModifierModel>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TomeAdded? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			int tome = value.Tome;
			uint ownerId = value.OwnerId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanagedWithObjectHeader<int, uint>((byte)4, ref tome, ref ownerId);
			ListFormatter.SerializePackable<StatModifierModel, TBufferWriter>(ref writer, value.Upgrades);
			int rarity = value.Rarity;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanaged<int>(ref rarity);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref TomeAdded? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			int tome = default(int);
			uint ownerId = default(uint);
			List<StatModifierModel> upgrades;
			int rarity = default(int);
			if (b == 4)
			{
				if (value != null)
				{
					tome = value.Tome;
					ownerId = value.OwnerId;
					upgrades = value.Upgrades;
					rarity = value.Rarity;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref tome);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					ListFormatter.DeserializePackable<StatModifierModel>(ref reader, ref upgrades);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref rarity);
					goto IL_00f4;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int, uint>(ref tome, ref ownerId);
				upgrades = ListFormatter.DeserializePackable<StatModifierModel>(ref reader);
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref rarity);
			}
			else
			{
				if (b > 4)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(TomeAdded), (byte)4, b);
					return;
				}
				if (value == null)
				{
					tome = 0;
					ownerId = 0u;
					upgrades = null;
					rarity = 0;
				}
				else
				{
					tome = value.Tome;
					ownerId = value.OwnerId;
					upgrades = value.Upgrades;
					rarity = value.Rarity;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref tome);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
						if (b != 2)
						{
							ListFormatter.DeserializePackable<StatModifierModel>(ref reader, ref upgrades);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref rarity);
								_ = 4;
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_00f4;
				}
			}
			value = new TomeAdded
			{
				Tome = tome,
				OwnerId = ownerId,
				Upgrades = upgrades,
				Rarity = rarity
			};
			return;
			IL_00f4:
			value.Tome = tome;
			value.OwnerId = ownerId;
			value.Upgrades = upgrades;
			value.Rarity = rarity;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class TornadoesSpawned : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<TornadoesSpawned>
	{
		[Preserve]
		private sealed class TornadoesSpawnedFormatter : MemoryPackFormatter<TornadoesSpawned>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TornadoesSpawned value)
			{
				TornadoesSpawned.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref TornadoesSpawned value)
			{
				TornadoesSpawned.Deserialize(ref reader, ref value);
			}
		}

		public int Amount { get; set; }

		static TornadoesSpawned()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<TornadoesSpawned>())
			{
				MemoryPackFormatterProvider.Register<TornadoesSpawned>((MemoryPackFormatter<TornadoesSpawned>)(object)new TornadoesSpawnedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<TornadoesSpawned[]>())
			{
				MemoryPackFormatterProvider.Register<TornadoesSpawned[]>((MemoryPackFormatter<TornadoesSpawned[]>)(object)new ArrayFormatter<TornadoesSpawned>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TornadoesSpawned? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			int amount = value.Amount;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanagedWithObjectHeader<int>((byte)1, ref amount);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref TornadoesSpawned? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			int amount = default(int);
			if (b == 1)
			{
				if (value != null)
				{
					amount = value.Amount;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref amount);
					goto IL_006b;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref amount);
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(TornadoesSpawned), (byte)1, b);
					return;
				}
				amount = ((value != null) ? value.Amount : 0);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref amount);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006b;
				}
			}
			value = new TornadoesSpawned
			{
				Amount = amount
			};
			return;
			IL_006b:
			value.Amount = amount;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class TumbleWeedDespawned : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<TumbleWeedDespawned>
	{
		[Preserve]
		private sealed class TumbleWeedDespawnedFormatter : MemoryPackFormatter<TumbleWeedDespawned>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TumbleWeedDespawned value)
			{
				TumbleWeedDespawned.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref TumbleWeedDespawned value)
			{
				TumbleWeedDespawned.Deserialize(ref reader, ref value);
			}
		}

		public uint NetplayId { get; set; }

		static TumbleWeedDespawned()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<TumbleWeedDespawned>())
			{
				MemoryPackFormatterProvider.Register<TumbleWeedDespawned>((MemoryPackFormatter<TumbleWeedDespawned>)(object)new TumbleWeedDespawnedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<TumbleWeedDespawned[]>())
			{
				MemoryPackFormatterProvider.Register<TumbleWeedDespawned[]>((MemoryPackFormatter<TumbleWeedDespawned[]>)(object)new ArrayFormatter<TumbleWeedDespawned>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TumbleWeedDespawned? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint netplayId = value.NetplayId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)1, ref netplayId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref TumbleWeedDespawned? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint netplayId = default(uint);
			if (b == 1)
			{
				if (value != null)
				{
					netplayId = value.NetplayId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
					goto IL_006b;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(TumbleWeedDespawned), (byte)1, b);
					return;
				}
				netplayId = ((value != null) ? value.NetplayId : 0u);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006b;
				}
			}
			value = new TumbleWeedDespawned
			{
				NetplayId = netplayId
			};
			return;
			IL_006b:
			value.NetplayId = netplayId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class TumbleWeedSpawned : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<TumbleWeedSpawned>
	{
		[Preserve]
		private sealed class TumbleWeedSpawnedFormatter : MemoryPackFormatter<TumbleWeedSpawned>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TumbleWeedSpawned value)
			{
				TumbleWeedSpawned.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref TumbleWeedSpawned value)
			{
				TumbleWeedSpawned.Deserialize(ref reader, ref value);
			}
		}

		public uint NetplayId { get; set; }

		public QuantizedVector3 Position { get; set; }

		public QuantizedVector3 Velocity { get; set; }

		static TumbleWeedSpawned()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<TumbleWeedSpawned>())
			{
				MemoryPackFormatterProvider.Register<TumbleWeedSpawned>((MemoryPackFormatter<TumbleWeedSpawned>)(object)new TumbleWeedSpawnedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<TumbleWeedSpawned[]>())
			{
				MemoryPackFormatterProvider.Register<TumbleWeedSpawned[]>((MemoryPackFormatter<TumbleWeedSpawned[]>)(object)new ArrayFormatter<TumbleWeedSpawned>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TumbleWeedSpawned? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint netplayId = value.NetplayId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)3, ref netplayId);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
			QuantizedVector3 velocity = value.Velocity;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref velocity);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref TumbleWeedSpawned? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint netplayId = default(uint);
			QuantizedVector3 position;
			QuantizedVector3 velocity;
			if (b == 3)
			{
				if (value != null)
				{
					netplayId = value.NetplayId;
					position = value.Position;
					velocity = value.Velocity;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref velocity);
					goto IL_00c8;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				velocity = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(TumbleWeedSpawned), (byte)3, b);
					return;
				}
				if (value == null)
				{
					netplayId = 0u;
					position = null;
					velocity = null;
				}
				else
				{
					netplayId = value.NetplayId;
					position = value.Position;
					velocity = value.Velocity;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref velocity);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00c8;
				}
			}
			value = new TumbleWeedSpawned
			{
				NetplayId = netplayId,
				Position = position,
				Velocity = velocity
			};
			return;
			IL_00c8:
			value.NetplayId = netplayId;
			value.Position = position;
			value.Velocity = velocity;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class TumbleWeedsUpdate : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<TumbleWeedsUpdate>
	{
		[Preserve]
		private sealed class TumbleWeedsUpdateFormatter : MemoryPackFormatter<TumbleWeedsUpdate>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TumbleWeedsUpdate value)
			{
				TumbleWeedsUpdate.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref TumbleWeedsUpdate value)
			{
				TumbleWeedsUpdate.Deserialize(ref reader, ref value);
			}
		}

		public TumbleWeedModel[] TumbleWeeds { get; set; }

		static TumbleWeedsUpdate()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<TumbleWeedsUpdate>())
			{
				MemoryPackFormatterProvider.Register<TumbleWeedsUpdate>((MemoryPackFormatter<TumbleWeedsUpdate>)(object)new TumbleWeedsUpdateFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<TumbleWeedsUpdate[]>())
			{
				MemoryPackFormatterProvider.Register<TumbleWeedsUpdate[]>((MemoryPackFormatter<TumbleWeedsUpdate[]>)(object)new ArrayFormatter<TumbleWeedsUpdate>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<TumbleWeedModel[]>())
			{
				MemoryPackFormatterProvider.Register<TumbleWeedModel[]>((MemoryPackFormatter<TumbleWeedModel[]>)(object)new ArrayFormatter<TumbleWeedModel>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TumbleWeedsUpdate? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)1);
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<TumbleWeedModel>>(ref writer).WritePackableArray<TumbleWeedModel>(value.TumbleWeeds);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref TumbleWeedsUpdate? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			TumbleWeedModel[] tumbleWeeds;
			if (b == 1)
			{
				if (value != null)
				{
					tumbleWeeds = value.TumbleWeeds;
					((MemoryPackReader)(ref reader)).ReadPackableArray<TumbleWeedModel>(ref tumbleWeeds);
					goto IL_006a;
				}
				tumbleWeeds = ((MemoryPackReader)(ref reader)).ReadPackableArray<TumbleWeedModel>();
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(TumbleWeedsUpdate), (byte)1, b);
					return;
				}
				tumbleWeeds = ((value != null) ? value.TumbleWeeds : null);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadPackableArray<TumbleWeedModel>(ref tumbleWeeds);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006a;
				}
			}
			value = new TumbleWeedsUpdate
			{
				TumbleWeeds = tumbleWeeds
			};
			return;
			IL_006a:
			value.TumbleWeeds = tumbleWeeds;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class WeaponAdded : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<WeaponAdded>
	{
		[Preserve]
		private sealed class WeaponAddedFormatter : MemoryPackFormatter<WeaponAdded>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref WeaponAdded value)
			{
				WeaponAdded.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref WeaponAdded value)
			{
				WeaponAdded.Deserialize(ref reader, ref value);
			}
		}

		public int Weapon { get; set; }

		public uint OwnerId { get; set; }

		public IEnumerable<StatModifierModel> Upgrades { get; set; }

		static WeaponAdded()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<WeaponAdded>())
			{
				MemoryPackFormatterProvider.Register<WeaponAdded>((MemoryPackFormatter<WeaponAdded>)(object)new WeaponAddedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<WeaponAdded[]>())
			{
				MemoryPackFormatterProvider.Register<WeaponAdded[]>((MemoryPackFormatter<WeaponAdded[]>)(object)new ArrayFormatter<WeaponAdded>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<IEnumerable<StatModifierModel>>())
			{
				MemoryPackFormatterProvider.Register<IEnumerable<StatModifierModel>>((MemoryPackFormatter<IEnumerable<StatModifierModel>>)(object)new InterfaceEnumerableFormatter<StatModifierModel>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref WeaponAdded? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			int weapon = value.Weapon;
			uint ownerId = value.OwnerId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanagedWithObjectHeader<int, uint>((byte)3, ref weapon, ref ownerId);
			IEnumerable<StatModifierModel> upgrades = value.Upgrades;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<IEnumerable<StatModifierModel>>>(ref writer).WriteValue<IEnumerable<StatModifierModel>>(ref upgrades);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref WeaponAdded? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			int weapon = default(int);
			uint ownerId = default(uint);
			IEnumerable<StatModifierModel> upgrades;
			if (b == 3)
			{
				if (value != null)
				{
					weapon = value.Weapon;
					ownerId = value.OwnerId;
					upgrades = value.Upgrades;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<StatModifierModel>>(ref upgrades);
					goto IL_00c3;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int, uint>(ref weapon, ref ownerId);
				upgrades = ((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<StatModifierModel>>();
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(WeaponAdded), (byte)3, b);
					return;
				}
				if (value == null)
				{
					weapon = 0;
					ownerId = 0u;
					upgrades = null;
				}
				else
				{
					weapon = value.Weapon;
					ownerId = value.OwnerId;
					upgrades = value.Upgrades;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref weapon);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<StatModifierModel>>(ref upgrades);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00c3;
				}
			}
			value = new WeaponAdded
			{
				Weapon = weapon,
				OwnerId = ownerId,
				Upgrades = upgrades
			};
			return;
			IL_00c3:
			value.Weapon = weapon;
			value.OwnerId = ownerId;
			value.Upgrades = upgrades;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class StatModifierModel : IMemoryPackable<StatModifierModel>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class StatModifierModelFormatter : MemoryPackFormatter<StatModifierModel>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StatModifierModel value)
			{
				StatModifierModel.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref StatModifierModel value)
			{
				StatModifierModel.Deserialize(ref reader, ref value);
			}
		}

		public int StatType { get; set; }

		public float Value { get; set; }

		public int ModificationType { get; set; }

		static StatModifierModel()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<StatModifierModel>())
			{
				MemoryPackFormatterProvider.Register<StatModifierModel>((MemoryPackFormatter<StatModifierModel>)(object)new StatModifierModelFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<StatModifierModel[]>())
			{
				MemoryPackFormatterProvider.Register<StatModifierModel[]>((MemoryPackFormatter<StatModifierModel[]>)(object)new ArrayFormatter<StatModifierModel>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StatModifierModel? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			int statType = value.StatType;
			float value2 = value.Value;
			int modificationType = value.ModificationType;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanagedWithObjectHeader<int, float, int>((byte)3, ref statType, ref value2, ref modificationType);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref StatModifierModel? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			int statType = default(int);
			float value2 = default(float);
			int modificationType = default(int);
			if (b == 3)
			{
				if (value != null)
				{
					statType = value.StatType;
					value2 = value.Value;
					modificationType = value.ModificationType;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref statType);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref value2);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref modificationType);
					goto IL_00c2;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int, float, int>(ref statType, ref value2, ref modificationType);
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(StatModifierModel), (byte)3, b);
					return;
				}
				if (value == null)
				{
					statType = 0;
					value2 = 0f;
					modificationType = 0;
				}
				else
				{
					statType = value.StatType;
					value2 = value.Value;
					modificationType = value.ModificationType;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref statType);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref value2);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref modificationType);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00c2;
				}
			}
			value = new StatModifierModel
			{
				StatType = statType,
				Value = value2,
				ModificationType = modificationType
			};
			return;
			IL_00c2:
			value.StatType = statType;
			value.Value = value2;
			value.ModificationType = modificationType;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class RelayEnvelope : IMemoryPackable<RelayEnvelope>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class RelayEnvelopeFormatter : MemoryPackFormatter<RelayEnvelope>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref RelayEnvelope value)
			{
				RelayEnvelope.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref RelayEnvelope value)
			{
				RelayEnvelope.Deserialize(ref reader, ref value);
			}
		}

		public ICollection<uint> ToFilters = Array.Empty<uint>();

		public byte[] Payload = Array.Empty<byte>();

		public uint TargetConnectionId { get; set; }

		public bool HaveTarget { get; set; }

		static RelayEnvelope()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<RelayEnvelope>())
			{
				MemoryPackFormatterProvider.Register<RelayEnvelope>((MemoryPackFormatter<RelayEnvelope>)(object)new RelayEnvelopeFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<RelayEnvelope[]>())
			{
				MemoryPackFormatterProvider.Register<RelayEnvelope[]>((MemoryPackFormatter<RelayEnvelope[]>)(object)new ArrayFormatter<RelayEnvelope>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<ICollection<uint>>())
			{
				MemoryPackFormatterProvider.Register<ICollection<uint>>((MemoryPackFormatter<ICollection<uint>>)(object)new InterfaceCollectionFormatter<uint>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<byte[]>())
			{
				MemoryPackFormatterProvider.Register<byte[]>((MemoryPackFormatter<byte[]>)(object)new ArrayFormatter<byte>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref RelayEnvelope? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint targetConnectionId = value.TargetConnectionId;
			bool haveTarget = value.HaveTarget;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, bool>((byte)4, ref targetConnectionId, ref haveTarget);
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<ICollection<uint>>>(ref writer).WriteValue<ICollection<uint>>(ref value.ToFilters);
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<byte>>(ref writer).WriteUnmanagedArray<byte>(value.Payload);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref RelayEnvelope? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint targetConnectionId = default(uint);
			bool haveTarget = default(bool);
			ICollection<uint> toFilters;
			byte[] payload;
			if (b == 4)
			{
				if (value != null)
				{
					targetConnectionId = value.TargetConnectionId;
					haveTarget = value.HaveTarget;
					toFilters = value.ToFilters;
					payload = value.Payload;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref targetConnectionId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref haveTarget);
					((MemoryPackReader)(ref reader)).ReadValue<ICollection<uint>>(ref toFilters);
					((MemoryPackReader)(ref reader)).ReadUnmanagedArray<byte>(ref payload);
					goto IL_00f4;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, bool>(ref targetConnectionId, ref haveTarget);
				toFilters = ((MemoryPackReader)(ref reader)).ReadValue<ICollection<uint>>();
				payload = ((MemoryPackReader)(ref reader)).ReadUnmanagedArray<byte>();
			}
			else
			{
				if (b > 4)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(RelayEnvelope), (byte)4, b);
					return;
				}
				if (value == null)
				{
					targetConnectionId = 0u;
					haveTarget = false;
					toFilters = null;
					payload = null;
				}
				else
				{
					targetConnectionId = value.TargetConnectionId;
					haveTarget = value.HaveTarget;
					toFilters = value.ToFilters;
					payload = value.Payload;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref targetConnectionId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref haveTarget);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadValue<ICollection<uint>>(ref toFilters);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanagedArray<byte>(ref payload);
								_ = 4;
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_00f4;
				}
			}
			value = new RelayEnvelope
			{
				TargetConnectionId = targetConnectionId,
				HaveTarget = haveTarget,
				ToFilters = toFilters,
				Payload = payload
			};
			return;
			IL_00f4:
			value.TargetConnectionId = targetConnectionId;
			value.HaveTarget = haveTarget;
			value.ToFilters = toFilters;
			value.Payload = payload;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class MatchInfo : IWsMessage, IMemoryPackFormatterRegister, IMemoryPackable<MatchInfo>
	{
		[Preserve]
		private sealed class MatchInfoFormatter : MemoryPackFormatter<MatchInfo>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref MatchInfo value)
			{
				MatchInfo.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref MatchInfo value)
			{
				MatchInfo.Deserialize(ref reader, ref value);
			}
		}

		public IEnumerable<PeerInfo> Peers { get; set; } = Array.Empty<PeerInfo>();

		public uint Seed { get; set; }

		public bool EnabledSharedExperience { get; set; }

		static MatchInfo()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<MatchInfo>())
			{
				MemoryPackFormatterProvider.Register<MatchInfo>((MemoryPackFormatter<MatchInfo>)(object)new MatchInfoFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<MatchInfo[]>())
			{
				MemoryPackFormatterProvider.Register<MatchInfo[]>((MemoryPackFormatter<MatchInfo[]>)(object)new ArrayFormatter<MatchInfo>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<IEnumerable<PeerInfo>>())
			{
				MemoryPackFormatterProvider.Register<IEnumerable<PeerInfo>>((MemoryPackFormatter<IEnumerable<PeerInfo>>)(object)new InterfaceEnumerableFormatter<PeerInfo>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref MatchInfo? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)3);
			IEnumerable<PeerInfo> peers = value.Peers;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<IEnumerable<PeerInfo>>>(ref writer).WriteValue<IEnumerable<PeerInfo>>(ref peers);
			uint seed = value.Seed;
			bool enabledSharedExperience = value.EnabledSharedExperience;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint, bool>(ref seed, ref enabledSharedExperience);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref MatchInfo? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			IEnumerable<PeerInfo> peers;
			uint seed = default(uint);
			bool enabledSharedExperience = default(bool);
			if (b == 3)
			{
				if (value != null)
				{
					peers = value.Peers;
					seed = value.Seed;
					enabledSharedExperience = value.EnabledSharedExperience;
					((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<PeerInfo>>(ref peers);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref seed);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref enabledSharedExperience);
					goto IL_00c3;
				}
				peers = ((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<PeerInfo>>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, bool>(ref seed, ref enabledSharedExperience);
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(MatchInfo), (byte)3, b);
					return;
				}
				if (value == null)
				{
					peers = null;
					seed = 0u;
					enabledSharedExperience = false;
				}
				else
				{
					peers = value.Peers;
					seed = value.Seed;
					enabledSharedExperience = value.EnabledSharedExperience;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadValue<IEnumerable<PeerInfo>>(ref peers);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref seed);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref enabledSharedExperience);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00c3;
				}
			}
			value = new MatchInfo
			{
				Peers = peers,
				Seed = seed,
				EnabledSharedExperience = enabledSharedExperience
			};
			return;
			IL_00c3:
			value.Peers = peers;
			value.Seed = seed;
			value.EnabledSharedExperience = enabledSharedExperience;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class PeerInfo : IMemoryPackable<PeerInfo>, IMemoryPackFormatterRegister
	{
		[Preserve]
		private sealed class PeerInfoFormatter : MemoryPackFormatter<PeerInfo>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PeerInfo value)
			{
				PeerInfo.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref PeerInfo value)
			{
				PeerInfo.Deserialize(ref reader, ref value);
			}
		}

		public uint ConnectionId { get; set; }

		public bool? IsHost { get; set; }

		public uint HostConnectionId { get; set; }

		public string Name { get; set; }

		static PeerInfo()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<PeerInfo>())
			{
				MemoryPackFormatterProvider.Register<PeerInfo>((MemoryPackFormatter<PeerInfo>)(object)new PeerInfoFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<PeerInfo[]>())
			{
				MemoryPackFormatterProvider.Register<PeerInfo[]>((MemoryPackFormatter<PeerInfo[]>)(object)new ArrayFormatter<PeerInfo>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<bool?>())
			{
				MemoryPackFormatterProvider.Register<bool?>((MemoryPackFormatter<bool?>)(object)new NullableFormatter<bool>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PeerInfo? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint connectionId = value.ConnectionId;
			bool? isHost = value.IsHost;
			uint hostConnectionId = value.HostConnectionId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).DangerousWriteUnmanagedWithObjectHeader<uint, bool?, uint>((byte)4, ref connectionId, ref isHost, ref hostConnectionId);
			writer.WriteString(value.Name);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref PeerInfo? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint connectionId = default(uint);
			bool? isHost = default(bool?);
			uint hostConnectionId = default(uint);
			string name;
			if (b == 4)
			{
				if (value != null)
				{
					connectionId = value.ConnectionId;
					isHost = value.IsHost;
					hostConnectionId = value.HostConnectionId;
					name = value.Name;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					((MemoryPackReader)(ref reader)).DangerousReadUnmanaged<bool?>(ref isHost);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref hostConnectionId);
					name = ((MemoryPackReader)(ref reader)).ReadString();
					goto IL_00f8;
				}
				((MemoryPackReader)(ref reader)).DangerousReadUnmanaged<uint, bool?, uint>(ref connectionId, ref isHost, ref hostConnectionId);
				name = ((MemoryPackReader)(ref reader)).ReadString();
			}
			else
			{
				if (b > 4)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(PeerInfo), (byte)4, b);
					return;
				}
				if (value == null)
				{
					connectionId = 0u;
					isHost = null;
					hostConnectionId = 0u;
					name = null;
				}
				else
				{
					connectionId = value.ConnectionId;
					isHost = value.IsHost;
					hostConnectionId = value.HostConnectionId;
					name = value.Name;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).DangerousReadUnmanaged<bool?>(ref isHost);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref hostConnectionId);
							if (b != 3)
							{
								name = ((MemoryPackReader)(ref reader)).ReadString();
								_ = 4;
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_00f8;
				}
			}
			value = new PeerInfo
			{
				ConnectionId = connectionId,
				IsHost = isHost,
				HostConnectionId = hostConnectionId,
				Name = name
			};
			return;
			IL_00f8:
			value.ConnectionId = connectionId;
			value.IsHost = isHost;
			value.HostConnectionId = hostConnectionId;
			value.Name = name;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class MatchmakingServerConnectionStatus : IWsMessage, IMemoryPackFormatterRegister, IMemoryPackable<MatchmakingServerConnectionStatus>
	{
		[Preserve]
		private sealed class MatchmakingServerConnectionStatusFormatter : MemoryPackFormatter<MatchmakingServerConnectionStatus>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref MatchmakingServerConnectionStatus value)
			{
				MatchmakingServerConnectionStatus.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref MatchmakingServerConnectionStatus value)
			{
				MatchmakingServerConnectionStatus.Deserialize(ref reader, ref value);
			}
		}

		public bool HasJoined { get; set; }

		public uint ConnectionId { get; set; }

		public string RoomCode { get; set; }

		public string Message { get; set; }

		static MatchmakingServerConnectionStatus()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<MatchmakingServerConnectionStatus>())
			{
				MemoryPackFormatterProvider.Register<MatchmakingServerConnectionStatus>((MemoryPackFormatter<MatchmakingServerConnectionStatus>)(object)new MatchmakingServerConnectionStatusFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<MatchmakingServerConnectionStatus[]>())
			{
				MemoryPackFormatterProvider.Register<MatchmakingServerConnectionStatus[]>((MemoryPackFormatter<MatchmakingServerConnectionStatus[]>)(object)new ArrayFormatter<MatchmakingServerConnectionStatus>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref MatchmakingServerConnectionStatus? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			bool hasJoined = value.HasJoined;
			uint connectionId = value.ConnectionId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<bool>>(ref writer).WriteUnmanagedWithObjectHeader<bool, uint>((byte)4, ref hasJoined, ref connectionId);
			writer.WriteString(value.RoomCode);
			writer.WriteString(value.Message);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref MatchmakingServerConnectionStatus? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			bool hasJoined = default(bool);
			uint connectionId = default(uint);
			string roomCode;
			string message;
			if (b == 4)
			{
				if (value != null)
				{
					hasJoined = value.HasJoined;
					connectionId = value.ConnectionId;
					roomCode = value.RoomCode;
					message = value.Message;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref hasJoined);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					roomCode = ((MemoryPackReader)(ref reader)).ReadString();
					message = ((MemoryPackReader)(ref reader)).ReadString();
					goto IL_00f2;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<bool, uint>(ref hasJoined, ref connectionId);
				roomCode = ((MemoryPackReader)(ref reader)).ReadString();
				message = ((MemoryPackReader)(ref reader)).ReadString();
			}
			else
			{
				if (b > 4)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(MatchmakingServerConnectionStatus), (byte)4, b);
					return;
				}
				if (value == null)
				{
					hasJoined = false;
					connectionId = 0u;
					roomCode = null;
					message = null;
				}
				else
				{
					hasJoined = value.HasJoined;
					connectionId = value.ConnectionId;
					roomCode = value.RoomCode;
					message = value.Message;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref hasJoined);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
						if (b != 2)
						{
							roomCode = ((MemoryPackReader)(ref reader)).ReadString();
							if (b != 3)
							{
								message = ((MemoryPackReader)(ref reader)).ReadString();
								_ = 4;
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_00f2;
				}
			}
			value = new MatchmakingServerConnectionStatus
			{
				HasJoined = hasJoined,
				ConnectionId = connectionId,
				RoomCode = roomCode,
				Message = message
			};
			return;
			IL_00f2:
			value.HasJoined = hasJoined;
			value.ConnectionId = connectionId;
			value.RoomCode = roomCode;
			value.Message = message;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class ServerConnectionStatus : IWsMessage, IMemoryPackFormatterRegister, IMemoryPackable<ServerConnectionStatus>
	{
		[Preserve]
		private sealed class ServerConnectionStatusFormatter : MemoryPackFormatter<ServerConnectionStatus>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ServerConnectionStatus value)
			{
				ServerConnectionStatus.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref ServerConnectionStatus value)
			{
				ServerConnectionStatus.Deserialize(ref reader, ref value);
			}
		}

		public bool HasJoined { get; set; }

		public uint ConnectionId { get; set; }

		static ServerConnectionStatus()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<ServerConnectionStatus>())
			{
				MemoryPackFormatterProvider.Register<ServerConnectionStatus>((MemoryPackFormatter<ServerConnectionStatus>)(object)new ServerConnectionStatusFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<ServerConnectionStatus[]>())
			{
				MemoryPackFormatterProvider.Register<ServerConnectionStatus[]>((MemoryPackFormatter<ServerConnectionStatus[]>)(object)new ArrayFormatter<ServerConnectionStatus>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ServerConnectionStatus? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			bool hasJoined = value.HasJoined;
			uint connectionId = value.ConnectionId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<bool>>(ref writer).WriteUnmanagedWithObjectHeader<bool, uint>((byte)2, ref hasJoined, ref connectionId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref ServerConnectionStatus? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			bool hasJoined = default(bool);
			uint connectionId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					hasJoined = value.HasJoined;
					connectionId = value.ConnectionId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref hasJoined);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<bool, uint>(ref hasJoined, ref connectionId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(ServerConnectionStatus), (byte)2, b);
					return;
				}
				if (value == null)
				{
					hasJoined = false;
					connectionId = 0u;
				}
				else
				{
					hasJoined = value.HasJoined;
					connectionId = value.ConnectionId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref hasJoined);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new ServerConnectionStatus
			{
				HasJoined = hasJoined,
				ConnectionId = connectionId
			};
			return;
			IL_0096:
			value.HasJoined = hasJoined;
			value.ConnectionId = connectionId;
		}
	}
}
namespace MegabonkTogether.Common.Messages.WsMessages
{
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class ClientDisconnected : IWsMessage, IMemoryPackFormatterRegister, IMemoryPackable<ClientDisconnected>
	{
		[Preserve]
		private sealed class ClientDisconnectedFormatter : MemoryPackFormatter<ClientDisconnected>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ClientDisconnected value)
			{
				ClientDisconnected.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref ClientDisconnected value)
			{
				ClientDisconnected.Deserialize(ref reader, ref value);
			}
		}

		public string RoomCode { get; set; }

		public uint ClientConnectionId { get; set; }

		static ClientDisconnected()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<ClientDisconnected>())
			{
				MemoryPackFormatterProvider.Register<ClientDisconnected>((MemoryPackFormatter<ClientDisconnected>)(object)new ClientDisconnectedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<ClientDisconnected[]>())
			{
				MemoryPackFormatterProvider.Register<ClientDisconnected[]>((MemoryPackFormatter<ClientDisconnected[]>)(object)new ArrayFormatter<ClientDisconnected>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ClientDisconnected? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)2);
			writer.WriteString(value.RoomCode);
			uint clientConnectionId = value.ClientConnectionId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint>(ref clientConnectionId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref ClientDisconnected? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint clientConnectionId = default(uint);
			string roomCode;
			if (b == 2)
			{
				if (value != null)
				{
					roomCode = value.RoomCode;
					clientConnectionId = value.ClientConnectionId;
					roomCode = ((MemoryPackReader)(ref reader)).ReadString();
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref clientConnectionId);
					goto IL_0099;
				}
				roomCode = ((MemoryPackReader)(ref reader)).ReadString();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref clientConnectionId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(ClientDisconnected), (byte)2, b);
					return;
				}
				if (value == null)
				{
					roomCode = null;
					clientConnectionId = 0u;
				}
				else
				{
					roomCode = value.RoomCode;
					clientConnectionId = value.ClientConnectionId;
				}
				if (b != 0)
				{
					roomCode = ((MemoryPackReader)(ref reader)).ReadString();
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref clientConnectionId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0099;
				}
			}
			value = new ClientDisconnected
			{
				RoomCode = roomCode,
				ClientConnectionId = clientConnectionId
			};
			return;
			IL_0099:
			value.RoomCode = roomCode;
			value.ClientConnectionId = clientConnectionId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class GameStarting : IWsMessage, IMemoryPackFormatterRegister, IMemoryPackable<GameStarting>
	{
		[Preserve]
		private sealed class GameStartingFormatter : MemoryPackFormatter<GameStarting>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref GameStarting value)
			{
				GameStarting.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref GameStarting value)
			{
				GameStarting.Deserialize(ref reader, ref value);
			}
		}

		public uint ConnectionId { get; set; }

		static GameStarting()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<GameStarting>())
			{
				MemoryPackFormatterProvider.Register<GameStarting>((MemoryPackFormatter<GameStarting>)(object)new GameStartingFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<GameStarting[]>())
			{
				MemoryPackFormatterProvider.Register<GameStarting[]>((MemoryPackFormatter<GameStarting[]>)(object)new ArrayFormatter<GameStarting>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref GameStarting? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint connectionId = value.ConnectionId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)1, ref connectionId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref GameStarting? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint connectionId = default(uint);
			if (b == 1)
			{
				if (value != null)
				{
					connectionId = value.ConnectionId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					goto IL_006b;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(GameStarting), (byte)1, b);
					return;
				}
				connectionId = ((value != null) ? value.ConnectionId : 0u);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref connectionId);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006b;
				}
			}
			value = new GameStarting
			{
				ConnectionId = connectionId
			};
			return;
			IL_006b:
			value.ConnectionId = connectionId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class GameStartingResponse : IWsMessage, IMemoryPackFormatterRegister, IMemoryPackable<GameStartingResponse>
	{
		[Preserve]
		private sealed class GameStartingResponseFormatter : MemoryPackFormatter<GameStartingResponse>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref GameStartingResponse value)
			{
				GameStartingResponse.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref GameStartingResponse value)
			{
				GameStartingResponse.Deserialize(ref reader, ref value);
			}
		}

		public bool IsSuccess { get; set; }

		static GameStartingResponse()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<GameStartingResponse>())
			{
				MemoryPackFormatterProvider.Register<GameStartingResponse>((MemoryPackFormatter<GameStartingResponse>)(object)new GameStartingResponseFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<GameStartingResponse[]>())
			{
				MemoryPackFormatterProvider.Register<GameStartingResponse[]>((MemoryPackFormatter<GameStartingResponse[]>)(object)new ArrayFormatter<GameStartingResponse>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref GameStartingResponse? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			bool isSuccess = value.IsSuccess;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<bool>>(ref writer).WriteUnmanagedWithObjectHeader<bool>((byte)1, ref isSuccess);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref GameStartingResponse? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			bool isSuccess = default(bool);
			if (b == 1)
			{
				if (value != null)
				{
					isSuccess = value.IsSuccess;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isSuccess);
					goto IL_006b;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isSuccess);
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(GameStartingResponse), (byte)1, b);
					return;
				}
				isSuccess = value != null && value.IsSuccess;
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isSuccess);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006b;
				}
			}
			value = new GameStartingResponse
			{
				IsSuccess = isSuccess
			};
			return;
			IL_006b:
			value.IsSuccess = isSuccess;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class HostDisconnected : IWsMessage, IMemoryPackFormatterRegister, IMemoryPackable<HostDisconnected>
	{
		[Preserve]
		private sealed class HostDisconnectedFormatter : MemoryPackFormatter<HostDisconnected>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref HostDisconnected value)
			{
				HostDisconnected.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref HostDisconnected value)
			{
				HostDisconnected.Deserialize(ref reader, ref value);
			}
		}

		public string RoomCode { get; set; }

		public uint HostConnectionId { get; set; }

		static HostDisconnected()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<HostDisconnected>())
			{
				MemoryPackFormatterProvider.Register<HostDisconnected>((MemoryPackFormatter<HostDisconnected>)(object)new HostDisconnectedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<HostDisconnected[]>())
			{
				MemoryPackFormatterProvider.Register<HostDisconnected[]>((MemoryPackFormatter<HostDisconnected[]>)(object)new ArrayFormatter<HostDisconnected>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref HostDisconnected? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			writer.WriteObjectHeader((byte)2);
			writer.WriteString(value.RoomCode);
			uint hostConnectionId = value.HostConnectionId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanaged<uint>(ref hostConnectionId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref HostDisconnected? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint hostConnectionId = default(uint);
			string roomCode;
			if (b == 2)
			{
				if (value != null)
				{
					roomCode = value.RoomCode;
					hostConnectionId = value.HostConnectionId;
					roomCode = ((MemoryPackReader)(ref reader)).ReadString();
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref hostConnectionId);
					goto IL_0099;
				}
				roomCode = ((MemoryPackReader)(ref reader)).ReadString();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref hostConnectionId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(HostDisconnected), (byte)2, b);
					return;
				}
				if (value == null)
				{
					roomCode = null;
					hostConnectionId = 0u;
				}
				else
				{
					roomCode = value.RoomCode;
					hostConnectionId = value.HostConnectionId;
				}
				if (b != 0)
				{
					roomCode = ((MemoryPackReader)(ref reader)).ReadString();
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref hostConnectionId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0099;
				}
			}
			value = new HostDisconnected
			{
				RoomCode = roomCode,
				HostConnectionId = hostConnectionId
			};
			return;
			IL_0099:
			value.RoomCode = roomCode;
			value.HostConnectionId = hostConnectionId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	[MemoryPackUnion(0, typeof(MatchmakingServerConnectionStatus))]
	[MemoryPackUnion(1, typeof(MatchInfo))]
	[MemoryPackUnion(2, typeof(ServerConnectionStatus))]
	[MemoryPackUnion(3, typeof(ClientReadyMessage))]
	[MemoryPackUnion(4, typeof(RunStatistics))]
	[MemoryPackUnion(5, typeof(GameStarting))]
	[MemoryPackUnion(6, typeof(GameStartingResponse))]
	[MemoryPackUnion(7, typeof(HostDisconnected))]
	[MemoryPackUnion(8, typeof(ClientDisconnected))]
	public interface IWsMessage : IMemoryPackFormatterRegister
	{
		[Preserve]
		public sealed class IWsMessageFormatter : MemoryPackFormatter<IWsMessage>
		{
			private static readonly Dictionary<Type, ushort> __typeToTag = new Dictionary<Type, ushort>(9)
			{
				{
					typeof(MatchmakingServerConnectionStatus),
					0
				},
				{
					typeof(MatchInfo),
					1
				},
				{
					typeof(ServerConnectionStatus),
					2
				},
				{
					typeof(ClientReadyMessage),
					3
				},
				{
					typeof(RunStatistics),
					4
				},
				{
					typeof(GameStarting),
					5
				},
				{
					typeof(GameStartingResponse),
					6
				},
				{
					typeof(HostDisconnected),
					7
				},
				{
					typeof(ClientDisconnected),
					8
				}
			};

			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref IWsMessage? value)
			{
				ushort value2;
				if (value == null)
				{
					writer.WriteNullUnionHeader();
				}
				else if (__typeToTag.TryGetValue(value.GetType(), out value2))
				{
					writer.WriteUnionHeader(value2);
					switch (value2)
					{
					case 0:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<MatchmakingServerConnectionStatus>>(ref writer).WritePackable<MatchmakingServerConnectionStatus>(ref Unsafe.As<IWsMessage, MatchmakingServerConnectionStatus>(ref value));
						break;
					case 1:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<MatchInfo>>(ref writer).WritePackable<MatchInfo>(ref Unsafe.As<IWsMessage, MatchInfo>(ref value));
						break;
					case 2:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<ServerConnectionStatus>>(ref writer).WritePackable<ServerConnectionStatus>(ref Unsafe.As<IWsMessage, ServerConnectionStatus>(ref value));
						break;
					case 3:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<ClientReadyMessage>>(ref writer).WritePackable<ClientReadyMessage>(ref Unsafe.As<IWsMessage, ClientReadyMessage>(ref value));
						break;
					case 4:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<RunStatistics>>(ref writer).WritePackable<RunStatistics>(ref Unsafe.As<IWsMessage, RunStatistics>(ref value));
						break;
					case 5:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<GameStarting>>(ref writer).WritePackable<GameStarting>(ref Unsafe.As<IWsMessage, GameStarting>(ref value));
						break;
					case 6:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<GameStartingResponse>>(ref writer).WritePackable<GameStartingResponse>(ref Unsafe.As<IWsMessage, GameStartingResponse>(ref value));
						break;
					case 7:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<HostDisconnected>>(ref writer).WritePackable<HostDisconnected>(ref Unsafe.As<IWsMessage, HostDisconnected>(ref value));
						break;
					case 8:
						Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<ClientDisconnected>>(ref writer).WritePackable<ClientDisconnected>(ref Unsafe.As<IWsMessage, ClientDisconnected>(ref value));
						break;
					}
				}
				else
				{
					MemoryPackSerializationException.ThrowNotFoundInUnionType(value.GetType(), typeof(IWsMessage));
				}
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref IWsMessage? value)
			{
				ushort num = default(ushort);
				if (!((MemoryPackReader)(ref reader)).TryReadUnionHeader(ref num))
				{
					value = null;
					return;
				}
				switch (num)
				{
				case 0:
					if (value is MatchmakingServerConnectionStatus)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<MatchmakingServerConnectionStatus>(ref Unsafe.As<IWsMessage, MatchmakingServerConnectionStatus>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<MatchmakingServerConnectionStatus>();
					}
					break;
				case 1:
					if (value is MatchInfo)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<MatchInfo>(ref Unsafe.As<IWsMessage, MatchInfo>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<MatchInfo>();
					}
					break;
				case 2:
					if (value is ServerConnectionStatus)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<ServerConnectionStatus>(ref Unsafe.As<IWsMessage, ServerConnectionStatus>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<ServerConnectionStatus>();
					}
					break;
				case 3:
					if (value is ClientReadyMessage)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<ClientReadyMessage>(ref Unsafe.As<IWsMessage, ClientReadyMessage>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<ClientReadyMessage>();
					}
					break;
				case 4:
					if (value is RunStatistics)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<RunStatistics>(ref Unsafe.As<IWsMessage, RunStatistics>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<RunStatistics>();
					}
					break;
				case 5:
					if (value is GameStarting)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<GameStarting>(ref Unsafe.As<IWsMessage, GameStarting>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<GameStarting>();
					}
					break;
				case 6:
					if (value is GameStartingResponse)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<GameStartingResponse>(ref Unsafe.As<IWsMessage, GameStartingResponse>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<GameStartingResponse>();
					}
					break;
				case 7:
					if (value is HostDisconnected)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<HostDisconnected>(ref Unsafe.As<IWsMessage, HostDisconnected>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<HostDisconnected>();
					}
					break;
				case 8:
					if (value is ClientDisconnected)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<ClientDisconnected>(ref Unsafe.As<IWsMessage, ClientDisconnected>(ref value));
					}
					else
					{
						value = ((MemoryPackReader)(ref reader)).ReadPackable<ClientDisconnected>();
					}
					break;
				default:
					MemoryPackSerializationException.ThrowInvalidTag(num, typeof(IWsMessage));
					break;
				}
			}
		}

		static IWsMessage()
		{
			RegisterFormatter();
		}

		[Preserve]
		static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<IWsMessage>())
			{
				MemoryPackFormatterProvider.Register<IWsMessage>((MemoryPackFormatter<IWsMessage>)(object)new IWsMessageFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<IWsMessage[]>())
			{
				MemoryPackFormatterProvider.Register<IWsMessage[]>((MemoryPackFormatter<IWsMessage[]>)(object)new ArrayFormatter<IWsMessage>());
			}
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class RunStatistics : IWsMessage, IMemoryPackFormatterRegister, IMemoryPackable<RunStatistics>
	{
		[Preserve]
		private sealed class RunStatisticsFormatter : MemoryPackFormatter<RunStatistics>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref RunStatistics value)
			{
				RunStatistics.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref RunStatistics value)
			{
				RunStatistics.Deserialize(ref reader, ref value);
			}
		}

		public int PlayerCount { get; set; }

		public string MapName { get; set; }

		public int StageLevel { get; set; }

		public List<string> Characters { get; set; } = new List<string>();

		static RunStatistics()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<RunStatistics>())
			{
				MemoryPackFormatterProvider.Register<RunStatistics>((MemoryPackFormatter<RunStatistics>)(object)new RunStatisticsFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<RunStatistics[]>())
			{
				MemoryPackFormatterProvider.Register<RunStatistics[]>((MemoryPackFormatter<RunStatistics[]>)(object)new ArrayFormatter<RunStatistics>());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<List<string>>())
			{
				MemoryPackFormatterProvider.Register<List<string>>((MemoryPackFormatter<List<string>>)(object)new ListFormatter<string>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref RunStatistics? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			int playerCount = value.PlayerCount;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanagedWithObjectHeader<int>((byte)4, ref playerCount);
			writer.WriteString(value.MapName);
			int stageLevel = value.StageLevel;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanaged<int>(ref stageLevel);
			List<string> characters = value.Characters;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<List<string>>>(ref writer).WriteValue<List<string>>(ref characters);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref RunStatistics? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			int playerCount = default(int);
			int stageLevel = default(int);
			List<string> characters;
			string mapName;
			if (b == 4)
			{
				if (value != null)
				{
					playerCount = value.PlayerCount;
					mapName = value.MapName;
					stageLevel = value.StageLevel;
					characters = value.Characters;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref playerCount);
					mapName = ((MemoryPackReader)(ref reader)).ReadString();
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref stageLevel);
					((MemoryPackReader)(ref reader)).ReadValue<List<string>>(ref characters);
					goto IL_00f8;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref playerCount);
				mapName = ((MemoryPackReader)(ref reader)).ReadString();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref stageLevel);
				characters = ((MemoryPackReader)(ref reader)).ReadValue<List<string>>();
			}
			else
			{
				if (b > 4)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(RunStatistics), (byte)4, b);
					return;
				}
				if (value == null)
				{
					playerCount = 0;
					mapName = null;
					stageLevel = 0;
					characters = null;
				}
				else
				{
					playerCount = value.PlayerCount;
					mapName = value.MapName;
					stageLevel = value.StageLevel;
					characters = value.Characters;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref playerCount);
					if (b != 1)
					{
						mapName = ((MemoryPackReader)(ref reader)).ReadString();
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref stageLevel);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadValue<List<string>>(ref characters);
								_ = 4;
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_00f8;
				}
			}
			value = new RunStatistics
			{
				PlayerCount = playerCount,
				MapName = mapName,
				StageLevel = stageLevel,
				Characters = characters
			};
			return;
			IL_00f8:
			value.PlayerCount = playerCount;
			value.MapName = mapName;
			value.StageLevel = stageLevel;
			value.Characters = characters;
		}
	}
}
namespace MegabonkTogether.Common.Messages.GameNetworkMessages
{
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class AddXp : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<AddXp>
	{
		[Preserve]
		private sealed class AddXpFormatter : MemoryPackFormatter<AddXp>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref AddXp value)
			{
				AddXp.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref AddXp value)
			{
				AddXp.Deserialize(ref reader, ref value);
			}
		}

		public int Amount { get; set; }

		public uint OwnerId { get; set; }

		public float LeftOverXp { get; set; }

		public int Xp { get; set; }

		static AddXp()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<AddXp>())
			{
				MemoryPackFormatterProvider.Register<AddXp>((MemoryPackFormatter<AddXp>)(object)new AddXpFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<AddXp[]>())
			{
				MemoryPackFormatterProvider.Register<AddXp[]>((MemoryPackFormatter<AddXp[]>)(object)new ArrayFormatter<AddXp>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref AddXp? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			int amount = value.Amount;
			uint ownerId = value.OwnerId;
			float leftOverXp = value.LeftOverXp;
			int xp = value.Xp;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanagedWithObjectHeader<int, uint, float, int>((byte)4, ref amount, ref ownerId, ref leftOverXp, ref xp);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref AddXp? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			int amount = default(int);
			uint ownerId = default(uint);
			float leftOverXp = default(float);
			int xp = default(int);
			if (b == 4)
			{
				if (value != null)
				{
					amount = value.Amount;
					ownerId = value.OwnerId;
					leftOverXp = value.LeftOverXp;
					xp = value.Xp;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref amount);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref leftOverXp);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref xp);
					goto IL_00f0;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int, uint, float, int>(ref amount, ref ownerId, ref leftOverXp, ref xp);
			}
			else
			{
				if (b > 4)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(AddXp), (byte)4, b);
					return;
				}
				if (value == null)
				{
					amount = 0;
					ownerId = 0u;
					leftOverXp = 0f;
					xp = 0;
				}
				else
				{
					amount = value.Amount;
					ownerId = value.OwnerId;
					leftOverXp = value.LeftOverXp;
					xp = value.Xp;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref amount);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<float>(ref leftOverXp);
							if (b != 3)
							{
								((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref xp);
								_ = 4;
							}
						}
					}
				}
				if (value != null)
				{
					goto IL_00f0;
				}
			}
			value = new AddXp
			{
				Amount = amount,
				OwnerId = ownerId,
				LeftOverXp = leftOverXp,
				Xp = xp
			};
			return;
			IL_00f0:
			value.Amount = amount;
			value.OwnerId = ownerId;
			value.LeftOverXp = leftOverXp;
			value.Xp = xp;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class CloseEncounter : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<CloseEncounter>
	{
		[Preserve]
		private sealed class CloseEncounterFormatter : MemoryPackFormatter<CloseEncounter>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref CloseEncounter value)
			{
				CloseEncounter.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref CloseEncounter value)
			{
				CloseEncounter.Deserialize(ref reader, ref value);
			}
		}

		static CloseEncounter()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<CloseEncounter>())
			{
				MemoryPackFormatterProvider.Register<CloseEncounter>((MemoryPackFormatter<CloseEncounter>)(object)new CloseEncounterFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<CloseEncounter[]>())
			{
				MemoryPackFormatterProvider.Register<CloseEncounter[]>((MemoryPackFormatter<CloseEncounter[]>)(object)new ArrayFormatter<CloseEncounter>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref CloseEncounter? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
			}
			else
			{
				writer.WriteObjectHeader((byte)0);
			}
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref CloseEncounter? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			if (b == 0)
			{
				if (value != null)
				{
					return;
				}
			}
			else
			{
				if (b > 0)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(CloseEncounter), (byte)0, b);
					return;
				}
				_ = value;
				if (value != null)
				{
					return;
				}
			}
			value = new CloseEncounter();
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class EncounterClosed : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<EncounterClosed>
	{
		[Preserve]
		private sealed class EncounterClosedFormatter : MemoryPackFormatter<EncounterClosed>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref EncounterClosed value)
			{
				EncounterClosed.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref EncounterClosed value)
			{
				EncounterClosed.Deserialize(ref reader, ref value);
			}
		}

		public uint OwnerId { get; set; }

		static EncounterClosed()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<EncounterClosed>())
			{
				MemoryPackFormatterProvider.Register<EncounterClosed>((MemoryPackFormatter<EncounterClosed>)(object)new EncounterClosedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<EncounterClosed[]>())
			{
				MemoryPackFormatterProvider.Register<EncounterClosed[]>((MemoryPackFormatter<EncounterClosed[]>)(object)new ArrayFormatter<EncounterClosed>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref EncounterClosed? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint ownerId = value.OwnerId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)1, ref ownerId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref EncounterClosed? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint ownerId = default(uint);
			if (b == 1)
			{
				if (value != null)
				{
					ownerId = value.OwnerId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					goto IL_006b;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(EncounterClosed), (byte)1, b);
					return;
				}
				ownerId = ((value != null) ? value.OwnerId : 0u);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006b;
				}
			}
			value = new EncounterClosed
			{
				OwnerId = ownerId
			};
			return;
			IL_006b:
			value.OwnerId = ownerId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class GoldChanged : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<GoldChanged>
	{
		[Preserve]
		private sealed class GoldChangedFormatter : MemoryPackFormatter<GoldChanged>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref GoldChanged value)
			{
				GoldChanged.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref GoldChanged value)
			{
				GoldChanged.Deserialize(ref reader, ref value);
			}
		}

		public int Amount { get; set; }

		public uint OwnerId { get; set; }

		static GoldChanged()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<GoldChanged>())
			{
				MemoryPackFormatterProvider.Register<GoldChanged>((MemoryPackFormatter<GoldChanged>)(object)new GoldChangedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<GoldChanged[]>())
			{
				MemoryPackFormatterProvider.Register<GoldChanged[]>((MemoryPackFormatter<GoldChanged[]>)(object)new ArrayFormatter<GoldChanged>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref GoldChanged? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			int amount = value.Amount;
			uint ownerId = value.OwnerId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanagedWithObjectHeader<int, uint>((byte)2, ref amount, ref ownerId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref GoldChanged? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			int amount = default(int);
			uint ownerId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					amount = value.Amount;
					ownerId = value.OwnerId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref amount);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int, uint>(ref amount, ref ownerId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(GoldChanged), (byte)2, b);
					return;
				}
				if (value == null)
				{
					amount = 0;
					ownerId = 0u;
				}
				else
				{
					amount = value.Amount;
					ownerId = value.OwnerId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref amount);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new GoldChanged
			{
				Amount = amount,
				OwnerId = ownerId
			};
			return;
			IL_0096:
			value.Amount = amount;
			value.OwnerId = ownerId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class HatChanged : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<HatChanged>
	{
		[Preserve]
		private sealed class HatChangedFormatter : MemoryPackFormatter<HatChanged>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref HatChanged value)
			{
				HatChanged.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref HatChanged value)
			{
				HatChanged.Deserialize(ref reader, ref value);
			}
		}

		public uint OwnerId { get; set; }

		public int EHat { get; set; }

		static HatChanged()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<HatChanged>())
			{
				MemoryPackFormatterProvider.Register<HatChanged>((MemoryPackFormatter<HatChanged>)(object)new HatChangedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<HatChanged[]>())
			{
				MemoryPackFormatterProvider.Register<HatChanged[]>((MemoryPackFormatter<HatChanged[]>)(object)new ArrayFormatter<HatChanged>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref HatChanged? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint ownerId = value.OwnerId;
			int eHat = value.EHat;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, int>((byte)2, ref ownerId, ref eHat);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref HatChanged? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint ownerId = default(uint);
			int eHat = default(int);
			if (b == 2)
			{
				if (value != null)
				{
					ownerId = value.OwnerId;
					eHat = value.EHat;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref eHat);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, int>(ref ownerId, ref eHat);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(HatChanged), (byte)2, b);
					return;
				}
				if (value == null)
				{
					ownerId = 0u;
					eHat = 0;
				}
				else
				{
					ownerId = value.OwnerId;
					eHat = value.EHat;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref eHat);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new HatChanged
			{
				OwnerId = ownerId,
				EHat = eHat
			};
			return;
			IL_0096:
			value.OwnerId = ownerId;
			value.EHat = eHat;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class InteractableCharacterFightEnemySpawned : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<InteractableCharacterFightEnemySpawned>
	{
		[Preserve]
		private sealed class InteractableCharacterFightEnemySpawnedFormatter : MemoryPackFormatter<InteractableCharacterFightEnemySpawned>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref InteractableCharacterFightEnemySpawned value)
			{
				InteractableCharacterFightEnemySpawned.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref InteractableCharacterFightEnemySpawned value)
			{
				InteractableCharacterFightEnemySpawned.Deserialize(ref reader, ref value);
			}
		}

		public uint NetplayId { get; set; }

		static InteractableCharacterFightEnemySpawned()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<InteractableCharacterFightEnemySpawned>())
			{
				MemoryPackFormatterProvider.Register<InteractableCharacterFightEnemySpawned>((MemoryPackFormatter<InteractableCharacterFightEnemySpawned>)(object)new InteractableCharacterFightEnemySpawnedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<InteractableCharacterFightEnemySpawned[]>())
			{
				MemoryPackFormatterProvider.Register<InteractableCharacterFightEnemySpawned[]>((MemoryPackFormatter<InteractableCharacterFightEnemySpawned[]>)(object)new ArrayFormatter<InteractableCharacterFightEnemySpawned>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref InteractableCharacterFightEnemySpawned? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint netplayId = value.NetplayId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)1, ref netplayId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref InteractableCharacterFightEnemySpawned? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint netplayId = default(uint);
			if (b == 1)
			{
				if (value != null)
				{
					netplayId = value.NetplayId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
					goto IL_006b;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
			}
			else
			{
				if (b > 1)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(InteractableCharacterFightEnemySpawned), (byte)1, b);
					return;
				}
				netplayId = ((value != null) ? value.NetplayId : 0u);
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
					_ = 1;
				}
				if (value != null)
				{
					goto IL_006b;
				}
			}
			value = new InteractableCharacterFightEnemySpawned
			{
				NetplayId = netplayId
			};
			return;
			IL_006b:
			value.NetplayId = netplayId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class ItemAdded : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<ItemAdded>
	{
		[Preserve]
		private sealed class ItemAddedFormatter : MemoryPackFormatter<ItemAdded>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ItemAdded value)
			{
				ItemAdded.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref ItemAdded value)
			{
				ItemAdded.Deserialize(ref reader, ref value);
			}
		}

		public int EItem { get; set; }

		public uint OwnerId { get; set; }

		static ItemAdded()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<ItemAdded>())
			{
				MemoryPackFormatterProvider.Register<ItemAdded>((MemoryPackFormatter<ItemAdded>)(object)new ItemAddedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<ItemAdded[]>())
			{
				MemoryPackFormatterProvider.Register<ItemAdded[]>((MemoryPackFormatter<ItemAdded[]>)(object)new ArrayFormatter<ItemAdded>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ItemAdded? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			int eItem = value.EItem;
			uint ownerId = value.OwnerId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanagedWithObjectHeader<int, uint>((byte)2, ref eItem, ref ownerId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref ItemAdded? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			int eItem = default(int);
			uint ownerId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					eItem = value.EItem;
					ownerId = value.OwnerId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref eItem);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int, uint>(ref eItem, ref ownerId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(ItemAdded), (byte)2, b);
					return;
				}
				if (value == null)
				{
					eItem = 0;
					ownerId = 0u;
				}
				else
				{
					eItem = value.EItem;
					ownerId = value.OwnerId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref eItem);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new ItemAdded
			{
				EItem = eItem,
				OwnerId = ownerId
			};
			return;
			IL_0096:
			value.EItem = eItem;
			value.OwnerId = ownerId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class ItemRemoved : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<ItemRemoved>
	{
		[Preserve]
		private sealed class ItemRemovedFormatter : MemoryPackFormatter<ItemRemoved>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ItemRemoved value)
			{
				ItemRemoved.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref ItemRemoved value)
			{
				ItemRemoved.Deserialize(ref reader, ref value);
			}
		}

		public int EItem { get; set; }

		public uint OwnerId { get; set; }

		static ItemRemoved()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<ItemRemoved>())
			{
				MemoryPackFormatterProvider.Register<ItemRemoved>((MemoryPackFormatter<ItemRemoved>)(object)new ItemRemovedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<ItemRemoved[]>())
			{
				MemoryPackFormatterProvider.Register<ItemRemoved[]>((MemoryPackFormatter<ItemRemoved[]>)(object)new ArrayFormatter<ItemRemoved>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref ItemRemoved? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			int eItem = value.EItem;
			uint ownerId = value.OwnerId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<int>>(ref writer).WriteUnmanagedWithObjectHeader<int, uint>((byte)2, ref eItem, ref ownerId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref ItemRemoved? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			int eItem = default(int);
			uint ownerId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					eItem = value.EItem;
					ownerId = value.OwnerId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref eItem);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<int, uint>(ref eItem, ref ownerId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(ItemRemoved), (byte)2, b);
					return;
				}
				if (value == null)
				{
					eItem = 0;
					ownerId = 0u;
				}
				else
				{
					eItem = value.EItem;
					ownerId = value.OwnerId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref eItem);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new ItemRemoved
			{
				EItem = eItem,
				OwnerId = ownerId
			};
			return;
			IL_0096:
			value.EItem = eItem;
			value.OwnerId = ownerId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class PlayerRespawned : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<PlayerRespawned>
	{
		[Preserve]
		private sealed class PlayerRespawnedFormatter : MemoryPackFormatter<PlayerRespawned>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PlayerRespawned value)
			{
				PlayerRespawned.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref PlayerRespawned value)
			{
				PlayerRespawned.Deserialize(ref reader, ref value);
			}
		}

		public uint OwnerId { get; set; }

		public QuantizedVector3 Position { get; set; }

		static PlayerRespawned()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<PlayerRespawned>())
			{
				MemoryPackFormatterProvider.Register<PlayerRespawned>((MemoryPackFormatter<PlayerRespawned>)(object)new PlayerRespawnedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<PlayerRespawned[]>())
			{
				MemoryPackFormatterProvider.Register<PlayerRespawned[]>((MemoryPackFormatter<PlayerRespawned[]>)(object)new ArrayFormatter<PlayerRespawned>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref PlayerRespawned? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint ownerId = value.OwnerId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)2, ref ownerId);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref PlayerRespawned? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint ownerId = default(uint);
			QuantizedVector3 position;
			if (b == 2)
			{
				if (value != null)
				{
					ownerId = value.OwnerId;
					position = value.Position;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					goto IL_009b;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(PlayerRespawned), (byte)2, b);
					return;
				}
				if (value == null)
				{
					ownerId = 0u;
					position = null;
				}
				else
				{
					ownerId = value.OwnerId;
					position = value.Position;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_009b;
				}
			}
			value = new PlayerRespawned
			{
				OwnerId = ownerId,
				Position = position
			};
			return;
			IL_009b:
			value.OwnerId = ownerId;
			value.Position = position;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedObjectInCrypt : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<SpawnedObjectInCrypt>
	{
		[Preserve]
		private sealed class SpawnedObjectInCryptFormatter : MemoryPackFormatter<SpawnedObjectInCrypt>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedObjectInCrypt value)
			{
				SpawnedObjectInCrypt.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedObjectInCrypt value)
			{
				SpawnedObjectInCrypt.Deserialize(ref reader, ref value);
			}
		}

		public uint NetplayId { get; set; }

		public QuantizedVector3 Position { get; set; }

		public bool IsCryptLeave { get; set; }

		static SpawnedObjectInCrypt()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedObjectInCrypt>())
			{
				MemoryPackFormatterProvider.Register<SpawnedObjectInCrypt>((MemoryPackFormatter<SpawnedObjectInCrypt>)(object)new SpawnedObjectInCryptFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedObjectInCrypt[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedObjectInCrypt[]>((MemoryPackFormatter<SpawnedObjectInCrypt[]>)(object)new ArrayFormatter<SpawnedObjectInCrypt>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedObjectInCrypt? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint netplayId = value.NetplayId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint>((byte)3, ref netplayId);
			QuantizedVector3 position = value.Position;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<QuantizedVector3>>(ref writer).WritePackable<QuantizedVector3>(ref position);
			bool isCryptLeave = value.IsCryptLeave;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<bool>>(ref writer).WriteUnmanaged<bool>(ref isCryptLeave);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedObjectInCrypt? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint netplayId = default(uint);
			QuantizedVector3 position;
			bool isCryptLeave = default(bool);
			if (b == 3)
			{
				if (value != null)
				{
					netplayId = value.NetplayId;
					position = value.Position;
					isCryptLeave = value.IsCryptLeave;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
					((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isCryptLeave);
					goto IL_00c9;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
				position = ((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>();
				((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isCryptLeave);
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedObjectInCrypt), (byte)3, b);
					return;
				}
				if (value == null)
				{
					netplayId = 0u;
					position = null;
					isCryptLeave = false;
				}
				else
				{
					netplayId = value.NetplayId;
					position = value.Position;
					isCryptLeave = value.IsCryptLeave;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref netplayId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadPackable<QuantizedVector3>(ref position);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isCryptLeave);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00c9;
				}
			}
			value = new SpawnedObjectInCrypt
			{
				NetplayId = netplayId,
				Position = position,
				IsCryptLeave = isCryptLeave
			};
			return;
			IL_00c9:
			value.NetplayId = netplayId;
			value.Position = position;
			value.IsCryptLeave = isCryptLeave;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class SpawnedReviver : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<SpawnedReviver>
	{
		[Preserve]
		private sealed class SpawnedReviverFormatter : MemoryPackFormatter<SpawnedReviver>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedReviver value)
			{
				SpawnedReviver.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref SpawnedReviver value)
			{
				SpawnedReviver.Deserialize(ref reader, ref value);
			}
		}

		public Vector3 Position { get; set; }

		public uint OwnerConnectionId { get; set; }

		public uint ReviverId { get; set; }

		static SpawnedReviver()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedReviver>())
			{
				MemoryPackFormatterProvider.Register<SpawnedReviver>((MemoryPackFormatter<SpawnedReviver>)(object)new SpawnedReviverFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<SpawnedReviver[]>())
			{
				MemoryPackFormatterProvider.Register<SpawnedReviver[]>((MemoryPackFormatter<SpawnedReviver[]>)(object)new ArrayFormatter<SpawnedReviver>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref SpawnedReviver? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			Vector3 position = value.Position;
			uint ownerConnectionId = value.OwnerConnectionId;
			uint reviverId = value.ReviverId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<Vector3>>(ref writer).WriteUnmanagedWithObjectHeader<Vector3, uint, uint>((byte)3, ref position, ref ownerConnectionId, ref reviverId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref SpawnedReviver? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			Vector3 position = default(Vector3);
			uint ownerConnectionId = default(uint);
			uint reviverId = default(uint);
			if (b == 3)
			{
				if (value != null)
				{
					position = value.Position;
					ownerConnectionId = value.OwnerConnectionId;
					reviverId = value.ReviverId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerConnectionId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref reviverId);
					goto IL_00c4;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3, uint, uint>(ref position, ref ownerConnectionId, ref reviverId);
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(SpawnedReviver), (byte)3, b);
					return;
				}
				if (value == null)
				{
					position = default(Vector3);
					ownerConnectionId = 0u;
					reviverId = 0u;
				}
				else
				{
					position = value.Position;
					ownerConnectionId = value.OwnerConnectionId;
					reviverId = value.ReviverId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<Vector3>(ref position);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerConnectionId);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref reviverId);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00c4;
				}
			}
			value = new SpawnedReviver
			{
				Position = position,
				OwnerConnectionId = ownerConnectionId,
				ReviverId = reviverId
			};
			return;
			IL_00c4:
			value.Position = position;
			value.OwnerConnectionId = ownerConnectionId;
			value.ReviverId = reviverId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class StartingChargingLamp : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<StartingChargingLamp>
	{
		[Preserve]
		private sealed class StartingChargingLampFormatter : MemoryPackFormatter<StartingChargingLamp>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StartingChargingLamp value)
			{
				StartingChargingLamp.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref StartingChargingLamp value)
			{
				StartingChargingLamp.Deserialize(ref reader, ref value);
			}
		}

		public uint LampNetplayId { get; set; }

		public uint PlayerChargingId { get; set; }

		static StartingChargingLamp()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<StartingChargingLamp>())
			{
				MemoryPackFormatterProvider.Register<StartingChargingLamp>((MemoryPackFormatter<StartingChargingLamp>)(object)new StartingChargingLampFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<StartingChargingLamp[]>())
			{
				MemoryPackFormatterProvider.Register<StartingChargingLamp[]>((MemoryPackFormatter<StartingChargingLamp[]>)(object)new ArrayFormatter<StartingChargingLamp>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StartingChargingLamp? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint lampNetplayId = value.LampNetplayId;
			uint playerChargingId = value.PlayerChargingId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref lampNetplayId, ref playerChargingId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref StartingChargingLamp? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint lampNetplayId = default(uint);
			uint playerChargingId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					lampNetplayId = value.LampNetplayId;
					playerChargingId = value.PlayerChargingId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref lampNetplayId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerChargingId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref lampNetplayId, ref playerChargingId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(StartingChargingLamp), (byte)2, b);
					return;
				}
				if (value == null)
				{
					lampNetplayId = 0u;
					playerChargingId = 0u;
				}
				else
				{
					lampNetplayId = value.LampNetplayId;
					playerChargingId = value.PlayerChargingId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref lampNetplayId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerChargingId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new StartingChargingLamp
			{
				LampNetplayId = lampNetplayId,
				PlayerChargingId = playerChargingId
			};
			return;
			IL_0096:
			value.LampNetplayId = lampNetplayId;
			value.PlayerChargingId = playerChargingId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class StoppingChargingLamp : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<StoppingChargingLamp>
	{
		[Preserve]
		private sealed class StoppingChargingLampFormatter : MemoryPackFormatter<StoppingChargingLamp>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StoppingChargingLamp value)
			{
				StoppingChargingLamp.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref StoppingChargingLamp value)
			{
				StoppingChargingLamp.Deserialize(ref reader, ref value);
			}
		}

		public uint LampNetplayId { get; set; }

		public uint PlayerChargingId { get; set; }

		static StoppingChargingLamp()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<StoppingChargingLamp>())
			{
				MemoryPackFormatterProvider.Register<StoppingChargingLamp>((MemoryPackFormatter<StoppingChargingLamp>)(object)new StoppingChargingLampFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<StoppingChargingLamp[]>())
			{
				MemoryPackFormatterProvider.Register<StoppingChargingLamp[]>((MemoryPackFormatter<StoppingChargingLamp[]>)(object)new ArrayFormatter<StoppingChargingLamp>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref StoppingChargingLamp? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint lampNetplayId = value.LampNetplayId;
			uint playerChargingId = value.PlayerChargingId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref lampNetplayId, ref playerChargingId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref StoppingChargingLamp? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint lampNetplayId = default(uint);
			uint playerChargingId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					lampNetplayId = value.LampNetplayId;
					playerChargingId = value.PlayerChargingId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref lampNetplayId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerChargingId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref lampNetplayId, ref playerChargingId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(StoppingChargingLamp), (byte)2, b);
					return;
				}
				if (value == null)
				{
					lampNetplayId = 0u;
					playerChargingId = 0u;
				}
				else
				{
					lampNetplayId = value.LampNetplayId;
					playerChargingId = value.PlayerChargingId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref lampNetplayId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref playerChargingId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new StoppingChargingLamp
			{
				LampNetplayId = lampNetplayId,
				PlayerChargingId = playerChargingId
			};
			return;
			IL_0096:
			value.LampNetplayId = lampNetplayId;
			value.PlayerChargingId = playerChargingId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class TimerStarted : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<TimerStarted>
	{
		[Preserve]
		private sealed class TimerStartedFormatter : MemoryPackFormatter<TimerStarted>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TimerStarted value)
			{
				TimerStarted.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref TimerStarted value)
			{
				TimerStarted.Deserialize(ref reader, ref value);
			}
		}

		public bool IsDungeonTimer { get; set; }

		public uint SenderId { get; set; }

		static TimerStarted()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<TimerStarted>())
			{
				MemoryPackFormatterProvider.Register<TimerStarted>((MemoryPackFormatter<TimerStarted>)(object)new TimerStartedFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<TimerStarted[]>())
			{
				MemoryPackFormatterProvider.Register<TimerStarted[]>((MemoryPackFormatter<TimerStarted[]>)(object)new ArrayFormatter<TimerStarted>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref TimerStarted? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			bool isDungeonTimer = value.IsDungeonTimer;
			uint senderId = value.SenderId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<bool>>(ref writer).WriteUnmanagedWithObjectHeader<bool, uint>((byte)2, ref isDungeonTimer, ref senderId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref TimerStarted? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			bool isDungeonTimer = default(bool);
			uint senderId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					isDungeonTimer = value.IsDungeonTimer;
					senderId = value.SenderId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isDungeonTimer);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref senderId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<bool, uint>(ref isDungeonTimer, ref senderId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(TimerStarted), (byte)2, b);
					return;
				}
				if (value == null)
				{
					isDungeonTimer = false;
					senderId = 0u;
				}
				else
				{
					isDungeonTimer = value.IsDungeonTimer;
					senderId = value.SenderId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref isDungeonTimer);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref senderId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new TimerStarted
			{
				IsDungeonTimer = isDungeonTimer,
				SenderId = senderId
			};
			return;
			IL_0096:
			value.IsDungeonTimer = isDungeonTimer;
			value.SenderId = senderId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class WantToStartFollowingPickup : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<WantToStartFollowingPickup>
	{
		[Preserve]
		private sealed class WantToStartFollowingPickupFormatter : MemoryPackFormatter<WantToStartFollowingPickup>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref WantToStartFollowingPickup value)
			{
				WantToStartFollowingPickup.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref WantToStartFollowingPickup value)
			{
				WantToStartFollowingPickup.Deserialize(ref reader, ref value);
			}
		}

		public uint PickupId { get; set; }

		public uint OwnerId { get; set; }

		static WantToStartFollowingPickup()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<WantToStartFollowingPickup>())
			{
				MemoryPackFormatterProvider.Register<WantToStartFollowingPickup>((MemoryPackFormatter<WantToStartFollowingPickup>)(object)new WantToStartFollowingPickupFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<WantToStartFollowingPickup[]>())
			{
				MemoryPackFormatterProvider.Register<WantToStartFollowingPickup[]>((MemoryPackFormatter<WantToStartFollowingPickup[]>)(object)new ArrayFormatter<WantToStartFollowingPickup>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref WantToStartFollowingPickup? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint pickupId = value.PickupId;
			uint ownerId = value.OwnerId;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, uint>((byte)2, ref pickupId, ref ownerId);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref WantToStartFollowingPickup? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint pickupId = default(uint);
			uint ownerId = default(uint);
			if (b == 2)
			{
				if (value != null)
				{
					pickupId = value.PickupId;
					ownerId = value.OwnerId;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref pickupId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					goto IL_0096;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, uint>(ref pickupId, ref ownerId);
			}
			else
			{
				if (b > 2)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(WantToStartFollowingPickup), (byte)2, b);
					return;
				}
				if (value == null)
				{
					pickupId = 0u;
					ownerId = 0u;
				}
				else
				{
					pickupId = value.PickupId;
					ownerId = value.OwnerId;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref pickupId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
						_ = 2;
					}
				}
				if (value != null)
				{
					goto IL_0096;
				}
			}
			value = new WantToStartFollowingPickup
			{
				PickupId = pickupId,
				OwnerId = ownerId
			};
			return;
			IL_0096:
			value.PickupId = pickupId;
			value.OwnerId = ownerId;
		}
	}
	[MemoryPackable(/*Could not decode attribute arguments.*/)]
	public class WeaponToggled : IGameNetworkMessage, IMemoryPackFormatterRegister, IMemoryPackable<WeaponToggled>
	{
		[Preserve]
		private sealed class WeaponToggledFormatter : MemoryPackFormatter<WeaponToggled>
		{
			[Preserve]
			public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref WeaponToggled value)
			{
				WeaponToggled.Serialize(ref writer, ref value);
			}

			[Preserve]
			public override void Deserialize(ref MemoryPackReader reader, ref WeaponToggled value)
			{
				WeaponToggled.Deserialize(ref reader, ref value);
			}
		}

		public uint OwnerId { get; set; }

		public bool Enabled { get; set; }

		public int EWeapon { get; set; }

		static WeaponToggled()
		{
			RegisterFormatter();
		}

		[Preserve]
		public static void RegisterFormatter()
		{
			if (!MemoryPackFormatterProvider.IsRegistered<WeaponToggled>())
			{
				MemoryPackFormatterProvider.Register<WeaponToggled>((MemoryPackFormatter<WeaponToggled>)(object)new WeaponToggledFormatter());
			}
			if (!MemoryPackFormatterProvider.IsRegistered<WeaponToggled[]>())
			{
				MemoryPackFormatterProvider.Register<WeaponToggled[]>((MemoryPackFormatter<WeaponToggled[]>)(object)new ArrayFormatter<WeaponToggled>());
			}
		}

		[Preserve]
		public static void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, ref WeaponToggled? value) where TBufferWriter : class, IBufferWriter<byte>
		{
			if (value == null)
			{
				writer.WriteNullObjectHeader();
				return;
			}
			uint ownerId = value.OwnerId;
			bool enabled = value.Enabled;
			int eWeapon = value.EWeapon;
			Unsafe.As<MemoryPackWriter<TBufferWriter>, MemoryPackWriter<uint>>(ref writer).WriteUnmanagedWithObjectHeader<uint, bool, int>((byte)3, ref ownerId, ref enabled, ref eWeapon);
		}

		[Preserve]
		public static void Deserialize(ref MemoryPackReader reader, ref WeaponToggled? value)
		{
			byte b = default(byte);
			if (!((MemoryPackReader)(ref reader)).TryReadObjectHeader(ref b))
			{
				value = null;
				return;
			}
			uint ownerId = default(uint);
			bool enabled = default(bool);
			int eWeapon = default(int);
			if (b == 3)
			{
				if (value != null)
				{
					ownerId = value.OwnerId;
					enabled = value.Enabled;
					eWeapon = value.EWeapon;
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref enabled);
					((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref eWeapon);
					goto IL_00be;
				}
				((MemoryPackReader)(ref reader)).ReadUnmanaged<uint, bool, int>(ref ownerId, ref enabled, ref eWeapon);
			}
			else
			{
				if (b > 3)
				{
					MemoryPackSerializationException.ThrowInvalidPropertyCount(typeof(WeaponToggled), (byte)3, b);
					return;
				}
				if (value == null)
				{
					ownerId = 0u;
					enabled = false;
					eWeapon = 0;
				}
				else
				{
					ownerId = value.OwnerId;
					enabled = value.Enabled;
					eWeapon = value.EWeapon;
				}
				if (b != 0)
				{
					((MemoryPackReader)(ref reader)).ReadUnmanaged<uint>(ref ownerId);
					if (b != 1)
					{
						((MemoryPackReader)(ref reader)).ReadUnmanaged<bool>(ref enabled);
						if (b != 2)
						{
							((MemoryPackReader)(ref reader)).ReadUnmanaged<int>(ref eWeapon);
							_ = 3;
						}
					}
				}
				if (value != null)
				{
					goto IL_00be;
				}
			}
			value = new WeaponToggled
			{
				OwnerId = ownerId,
				Enabled = enabled,
				EWeapon = eWeapon
			};
			return;
			IL_00be:
			value.OwnerId = ownerId;
			value.Enabled = enabled;
			value.EWeapon = eWeapon;
		}
	}
}
namespace MegabonkTogether.Common.Extensions
{
	public static class WebSocketsExtensions
	{
		public static async Task SendMessageAsync<T>(this WebSocket webSocket, T message) where T : IWsMessage
		{
			IWsMessage wsMessage = message;
			byte[] array = MemoryPackSerializer.Serialize<IWsMessage>(ref wsMessage, (MemoryPackSerializerOptions)null);
			ReadOnlyMemory<byte> buffer = new ReadOnlyMemory<byte>(array);
			await webSocket.SendAsync(buffer, WebSocketMessageType.Binary, endOfMessage: true, CancellationToken.None);
		}
	}
}