using System;
using System.Buffers;
using System.Buffers.Binary;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Net.Http;
using System.Net.NetworkInformation;
using System.Net.Security;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics.Arm;
using System.Runtime.Intrinsics.X86;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;
using GroovyCodecs.G711.aLaw;
using HarmonyLib;
using Il2Cpp;
using Il2CppCysharp.Threading.Tasks;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppInterop.Runtime.InteropTypes.Fields;
using Il2CppSLZ.Bonelab;
using Il2CppSLZ.Data;
using Il2CppSLZ.Interaction;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.AI;
using Il2CppSLZ.Marrow.Audio;
using Il2CppSLZ.Marrow.Circuits;
using Il2CppSLZ.Marrow.Combat;
using Il2CppSLZ.Marrow.Data;
using Il2CppSLZ.Marrow.Forklift;
using Il2CppSLZ.Marrow.Forklift.Model;
using Il2CppSLZ.Marrow.Input;
using Il2CppSLZ.Marrow.Interaction;
using Il2CppSLZ.Marrow.Pool;
using Il2CppSLZ.Marrow.PuppetMasta;
using Il2CppSLZ.Marrow.SceneStreaming;
using Il2CppSLZ.Marrow.Utilities;
using Il2CppSLZ.Marrow.VFX;
using Il2CppSLZ.Marrow.VoidLogic;
using Il2CppSLZ.Marrow.Warehouse;
using Il2CppSLZ.Marrow.Zones;
using Il2CppSLZ.VRMK;
using Il2CppSteamworks;
using Il2CppSystem;
using Il2CppSystem.Collections;
using Il2CppSystem.Collections.Generic;
using Il2CppTMPro;
using Il2CppUltEvents;
using LabFusion;
using LabFusion.Audio;
using LabFusion.Data;
using LabFusion.Data.Serializables;
using LabFusion.Downloading;
using LabFusion.Downloading.ModIO;
using LabFusion.Entities;
using LabFusion.Exceptions;
using LabFusion.Extensions;
using LabFusion.Grabbables;
using LabFusion.Marrow;
using LabFusion.Marrow.Circuits;
using LabFusion.Marrow.Combat;
using LabFusion.Marrow.Extenders;
using LabFusion.Marrow.Extensions;
using LabFusion.Marrow.Integration;
using LabFusion.Marrow.Messages;
using LabFusion.Marrow.Patching;
using LabFusion.Marrow.Pool;
using LabFusion.Marrow.Proxies;
using LabFusion.Marrow.Scene;
using LabFusion.Marrow.Serialization;
using LabFusion.Marrow.Zones;
using LabFusion.Math;
using LabFusion.Menu;
using LabFusion.Menu.Data;
using LabFusion.Menu.Gamemodes;
using LabFusion.MonoBehaviours;
using LabFusion.Network;
using LabFusion.Network.Proxy;
using LabFusion.Network.Serialization;
using LabFusion.Patching;
using LabFusion.Permissions;
using LabFusion.Player;
using LabFusion.Preferences;
using LabFusion.Preferences.Client;
using LabFusion.Preferences.Server;
using LabFusion.RPC;
using LabFusion.Representation;
using LabFusion.SDK.Achievements;
using LabFusion.SDK.Cosmetics;
using LabFusion.SDK.Extenders;
using LabFusion.SDK.Gamemodes;
using LabFusion.SDK.Lobbies;
using LabFusion.SDK.Messages;
using LabFusion.SDK.Metadata;
using LabFusion.SDK.Modules;
using LabFusion.SDK.MonoBehaviours;
using LabFusion.SDK.Points;
using LabFusion.SDK.Triggers;
using LabFusion.Safety;
using LabFusion.Scene;
using LabFusion.Senders;
using LabFusion.Support;
using LabFusion.UI;
using LabFusion.UI.Popups;
using LabFusion.Utilities;
using LabFusion.Voice;
using LabFusion.Voice.Unity;
using LabFusion.XML;
using LiteNetLib;
using LiteNetLib.Layers;
using LiteNetLib.Utils;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json.Linq;
using Steamworks;
using Steamworks.Data;
using Steamworks.Ugc;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.Video;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("LabFusion")]
[assembly: AssemblyFileVersion("1.14.2")]
[assembly: MelonInfo(typeof(FusionMod), "LabFusion", "1.14.2", "Lakatrazz", null)]
[assembly: MelonGame("Stress Level Zero", null)]
[assembly: MelonPriority(-10000)]
[assembly: MelonOptionalDependencies(new string[] { "Il2CppFacepunch.Steamworks.Win64" })]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.14.2.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace LabFusion
{
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct FusionVersion
	{
		public const byte VersionMajor = 1;

		public const byte VersionMinor = 14;

		public const short VersionPatch = 2;

		public const string VersionString = "1.14.2";
	}
	public class FusionMod : MelonMod
	{
		public const string ModName = "LabFusion";

		public const string ModAuthor = "Lakatrazz";

		public const string GameDeveloper = "Stress Level Zero";

		public static readonly Version Version = new Version(1, 14, 2);

		private static bool _hasAutoUpdater = false;

		public static string Changelog { get; internal set; } = null;


		public static string[] Credits { get; internal set; } = null;


		public static FusionMod Instance { get; private set; }

		public static Assembly FusionAssembly { get; private set; }

		public override void OnEarlyInitializeMelon()
		{
			Instance = this;
			FusionAssembly = ((MelonBase)this).MelonAssembly.Assembly;
			ModDownloadManager.DeleteTemporaryDirectories();
			PersistentData.OnPathInitialize();
			SteamAPILoader.OnLoadSteamAPI();
			PDController.OnInitializeMelon();
			PointItemManager.HookEvents();
			RpcManager.OnInitialize();
		}

		public override void OnInitializeMelon()
		{
			FusionFileLoader.OnInitializeMelon();
			ListLoader.OnInitializeMelon();
			LocalPlayer.OnInitializeMelon();
			VoiceSourceManager.OnInitializeMelon();
			InitializeBaseModules();
			NativeMessageHandler.RegisterHandlersFromAssembly(FusionAssembly);
			GrabGroupHandler.RegisterHandlersFromAssembly(FusionAssembly);
			NetworkLayer.RegisterLayersFromAssembly(FusionAssembly);
			GamemodeRegistration.LoadGamemodes(FusionAssembly);
			PointItemManager.LoadItems(FusionAssembly);
			AchievementManager.LoadAchievements(FusionAssembly);
			RpcManager.LoadRpcs(FusionAssembly);
			EntityComponentManager.LoadComponents(FusionAssembly);
			LobbyFilterManager.LoadBuiltInFilters();
			NetworkEntityManager.OnInitializeManager();
			NetworkPlayerManager.OnInitializeManager();
			PopupManager.OnInitializeMelon();
			GamemodeManager.OnInitializeMelon();
			GamemodeConditionsChecker.OnInitializeMelon();
			GamemodeRoundManager.OnInitializeMelon();
			AssetWarehouse.OnReady(Action.op_Implicit((Action)delegate
			{
				CosmeticLoader.OnAssetWarehouseReady();
			}));
			FusionPreferences.OnInitializePreferences();
			FusionPermissions.OnInitializeMelon();
			LobbyInfoManager.OnInitialize();
			MenuCreator.OnInitializeMelon();
			FusionSceneManager.Internal_OnInitializeMelon();
			MultiplayerHooking.OnLoadingBegin += OnLoadingBegin;
			NetworkSceneManager.OnInitializeMelon();
			NetworkLayerManager.OnInitializeMelon();
		}

		private static void InitializeBaseModules()
		{
			ModuleManager.LoadModules(FusionAssembly);
			SupportManager.LoadGameModule(FusionAssembly);
		}

		public override void OnLateInitializeMelon()
		{
			PersistentAssetCreator.OnLateInitializeMelon();
			PlayerAdditionsHelper.OnInitializeMelon();
			_hasAutoUpdater = MelonTypeBase<MelonPlugin>.RegisteredMelons.Any((MelonPlugin p) => ((MelonBase)p).Info.Name.Contains("LabFusion Updater"));
			if (!_hasAutoUpdater)
			{
				Notifier.Send(new Notification
				{
					SaveToMenu = false,
					ShowPopup = true,
					Message = "You do not have the Fusion AutoUpdater installed in your plugins folder!\nIt is recommended to install it in order to stay up to date.",
					Type = NotificationType.WARNING
				});
			}
		}

		public override void OnDeinitializeMelon()
		{
			NetworkLayerManager.LogOut();
			FusionFileLoader.OnDeinitializeMelon();
			PointItemManager.UnhookEvents();
			PlayerAdditionsHelper.OnDeinitializeMelon();
			SteamAPILoader.OnFreeSteamAPI();
		}

		public override void OnPreferencesLoaded()
		{
			FusionPreferences.OnPreferencesLoaded();
		}

		public static void OnMainSceneInitialized()
		{
			_ = ((Scannable)FusionSceneManager.Level).Title;
			NetworkEntityManager.OnCleanupIds();
			RigData.OnCacheRigInfo();
			PersistentAssetCreator.OnMainSceneInitialized();
			ConstrainerUtilities.OnMainSceneInitialized();
			MultiplayerHooking.InvokeOnMainSceneInitialized();
			FusionPlayer.OnMainSceneInitialized();
		}

		public static void OnMainSceneInitializeDelayed()
		{
			if (RigData.HasPlayer)
			{
				((Il2CppObjectBase)RigData.Refs.RigManager.ControllerRig).TryCast<OpenControllerRig>().quickmenuEnabled = true;
				PlayerRefs.Instance.PlayerBodyVitals.quickmenuEnabled = true;
				MenuCreator.CreateMenu();
			}
		}

		private void OnLoadingBegin()
		{
			ModIOThumbnailDownloader.ClearCache();
		}

		public override void OnUpdate()
		{
			NetworkInfo.BytesDown = 0;
			NetworkInfo.BytesUp = 0;
			ModIODownloader.UpdateQueue();
			TimeReferences.OnEarlyUpdate();
			FusionSceneManager.Internal_UpdateScene();
			PopupManager.OnUpdate();
			NetworkTickManager.OnUpdate(TimeReferences.UnscaledDeltaTime);
			float deltaTime = TimeReferences.DeltaTime;
			NetworkPlayerManager.OnUpdate(deltaTime);
			NetworkEntityManager.OnUpdate(deltaTime);
			FusionPlayer.OnUpdate();
			VoiceHelper.OnVoiceChatUpdate();
			InternalLayerHelpers.OnUpdateLayer();
			NetworkConnectionManager.OnUpdate(deltaTime);
			MultiplayerHooking.InvokeOnUpdate();
			GamemodeManager.OnUpdate();
			DelayUtilities.OnProcessDelays();
		}

		public override void OnFixedUpdate()
		{
			TimeReferences.OnEarlyFixedUpdate();
			LocalPlayer.OnFixedUpdate();
			PDController.OnFixedUpdate();
			float fixedDeltaTime = TimeReferences.FixedDeltaTime;
			NetworkPlayerManager.OnFixedUpdate(fixedDeltaTime);
			NetworkEntityManager.OnFixedUpdate(fixedDeltaTime);
			MultiplayerHooking.InvokeOnFixedUpdate();
			GamemodeManager.OnFixedUpdate();
		}

		public override void OnLateUpdate()
		{
			float deltaTime = TimeReferences.DeltaTime;
			NetworkPlayerManager.OnLateUpdate(deltaTime);
			NetworkEntityManager.OnLateUpdate(deltaTime);
			InternalLayerHelpers.OnLateUpdateLayer();
			MultiplayerHooking.InvokeOnLateUpdate();
			GamemodeManager.OnLateUpdate();
		}
	}
}
namespace LabFusion.Voice
{
	public interface IVoiceManager
	{
		List<IVoiceSpeaker> VoiceSpeakers { get; }

		bool CanTalk { get; }

		bool CanHear { get; }

		string[] InputDevices { get; }

		IVoiceSpeaker GetSpeaker(PlayerID id);

		void RemoveSpeaker(PlayerID id);

		IVoiceReceiver GetReceiver();

		void Enable();

		void Disable();

		void UpdateManager();

		void ClearManager();
	}
	public abstract class VoiceManager : IVoiceManager
	{
		protected List<IVoiceSpeaker> _voiceSpeakers = new List<IVoiceSpeaker>();

		private IVoiceReceiver _receiver;

		private bool _hasDisabledVoice = true;

		public List<IVoiceSpeaker> VoiceSpeakers => _voiceSpeakers;

		public virtual bool CanTalk => true;

		public virtual bool CanHear => true;

		public virtual string[] InputDevices => Array.Empty<string>();

		public void Enable()
		{
			_receiver = OnCreateReceiverOrDefault();
			_receiver?.Enable();
		}

		public void Disable()
		{
			if (_receiver != null)
			{
				_receiver.Disable();
				_receiver = null;
			}
			ClearManager();
		}

		protected bool TryGetSpeaker(PlayerID id, out IVoiceSpeaker speaker)
		{
			speaker = null;
			for (int i = 0; i < VoiceSpeakers.Count; i++)
			{
				IVoiceSpeaker voiceSpeaker = VoiceSpeakers[i];
				if (voiceSpeaker.ID == id)
				{
					speaker = voiceSpeaker;
					return true;
				}
			}
			return false;
		}

		protected abstract IVoiceSpeaker OnCreateSpeaker(PlayerID id);

		protected abstract IVoiceReceiver OnCreateReceiverOrDefault();

		public IVoiceSpeaker GetSpeaker(PlayerID id)
		{
			if (TryGetSpeaker(id, out var speaker))
			{
				return speaker;
			}
			IVoiceSpeaker voiceSpeaker = OnCreateSpeaker(id);
			VoiceSpeakers.Add(voiceSpeaker);
			return voiceSpeaker;
		}

		public IVoiceReceiver GetReceiver()
		{
			return _receiver;
		}

		public void UpdateManager()
		{
			UpdateSpeakers();
			UpdateReceiver();
		}

		private void UpdateSpeakers()
		{
			for (int i = 0; i < VoiceSpeakers.Count; i++)
			{
				VoiceSpeakers[i].Update();
			}
		}

		private void UpdateReceiver()
		{
			if (_receiver != null && CanTalk)
			{
				if (NetworkInfo.HasServer && !VoiceInfo.IsMuted)
				{
					_receiver.UpdateVoice(enabled: true);
					_hasDisabledVoice = false;
				}
				else if (!_hasDisabledVoice)
				{
					_receiver.UpdateVoice(enabled: false);
					_hasDisabledVoice = true;
				}
				if (_receiver.HasVoiceActivity())
				{
					PlayerSender.SendPlayerVoiceChat(_receiver.GetEncodedData());
				}
			}
		}

		public void RemoveSpeaker(PlayerID id)
		{
			IVoiceSpeaker voiceSpeaker = null;
			foreach (IVoiceSpeaker voiceSpeaker2 in VoiceSpeakers)
			{
				if (voiceSpeaker2.ID == id)
				{
					voiceSpeaker = voiceSpeaker2;
					break;
				}
			}
			if (voiceSpeaker != null)
			{
				voiceSpeaker.Cleanup();
				_voiceSpeakers.Remove(voiceSpeaker);
			}
		}

		public void ClearManager()
		{
			foreach (IVoiceSpeaker voiceSpeaker in VoiceSpeakers)
			{
				voiceSpeaker.Cleanup();
			}
			_voiceSpeakers.Clear();
		}
	}
	public interface IVoiceReceiver
	{
		float GetVoiceAmplitude();

		bool HasVoiceActivity();

		byte[] GetEncodedData();

		void UpdateVoice(bool enabled);

		void Enable();

		void Disable();
	}
	public interface IVoiceSpeaker
	{
		PlayerID ID { get; }

		float Volume { get; set; }

		float Amplitude { get; set; }

		void OnVoiceDataReceived(byte[] data);

		void Update();

		void Cleanup();
	}
	public abstract class VoiceSpeaker : IVoiceSpeaker
	{
		protected PlayerID _id;

		protected float _volume = 1f;

		public PlayerID ID => _id;

		public float Volume
		{
			get
			{
				return _volume;
			}
			set
			{
				_volume = value;
			}
		}

		public abstract float Amplitude { get; set; }

		public virtual void Update()
		{
		}

		public abstract void OnVoiceDataReceived(byte[] data);

		public abstract void Cleanup();
	}
	public class JawFlapper
	{
		public const float MaxAngle = 40f;

		private float _voiceLoudness;

		public float GetAngle()
		{
			return _voiceLoudness * 40f;
		}

		public void ClearJaw()
		{
			_voiceLoudness = 0f;
		}

		public void UpdateJaw(float amplitude, float deltaTime)
		{
			float b = ManagedMathf.Clamp01(amplitude * 2f);
			_voiceLoudness = ManagedMathf.Lerp(_voiceLoudness, b, Smoothing.CalculateDecay(12f, deltaTime));
		}
	}
	public static class VoiceConverter
	{
		public static readonly ALawEncoder G711Encoder = new ALawEncoder();

		public static readonly ALawDecoder G711Decoder = new ALawDecoder();

		public static void CopySamples(float[] from, short[] to, int sampleCount)
		{
			for (int i = 0; i < sampleCount; i++)
			{
				to[i] = ConvertSample(from[i]);
			}
		}

		public static void CopySamples(short[] from, float[] to, int sampleCount)
		{
			for (int i = 0; i < sampleCount; i++)
			{
				to[i] = ConvertSample(from[i]);
			}
		}

		public static short ConvertSample(float sample)
		{
			return (short)(sample * 32767f);
		}

		public static float ConvertSample(short sample)
		{
			return (float)sample / 32767f;
		}

		public static byte[] Encode(short[] samples)
		{
			return Compress(G711Encoder.Process(samples));
		}

		public static short[] Decode(byte[] bytes)
		{
			return G711Decoder.Process(Decompress(bytes));
		}

		public static byte[] Compress(byte[] data)
		{
			using MemoryStream memoryStream = new MemoryStream();
			using DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionLevel.SmallestSize);
			deflateStream.Write(data, 0, data.Length);
			deflateStream.Close();
			return memoryStream.ToArray();
		}

		public static byte[] Decompress(byte[] data)
		{
			using MemoryStream stream = new MemoryStream(data);
			using DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress);
			using MemoryStream memoryStream = new MemoryStream();
			deflateStream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}
	}
	public static class VoiceHelper
	{
		public static void OnVoiceChatUpdate()
		{
			VoiceInfo.VoiceManager?.UpdateManager();
		}

		public static void OnVoiceDataReceived(PlayerID player, byte[] data)
		{
			if (!VoiceInfo.IsDeafened)
			{
				(VoiceInfo.VoiceManager?.GetSpeaker(player))?.OnVoiceDataReceived(data);
			}
		}
	}
	public static class VoiceInfo
	{
		public static IVoiceManager VoiceManager => NetworkLayerManager.Layer?.VoiceManager;

		public static bool CanTalk => (VoiceManager?.CanTalk).GetValueOrDefault();

		public static bool CanHear => (VoiceManager?.CanHear).GetValueOrDefault();

		public static string[] InputDevices
		{
			get
			{
				if (VoiceManager == null)
				{
					return Array.Empty<string>();
				}
				return VoiceManager.InputDevices;
			}
		}

		public static bool ShowMuteIndicator
		{
			get
			{
				if (NetworkInfo.HasServer && ClientSettings.VoiceChat.Muted.Value)
				{
					return ClientSettings.VoiceChat.MutedIndicator.Value;
				}
				return false;
			}
		}

		public static float VoiceAmplitude => (VoiceManager?.GetReceiver()?.GetVoiceAmplitude()).GetValueOrDefault();

		public static bool HasVoiceActivity => (VoiceManager?.GetReceiver()?.HasVoiceActivity()).GetValueOrDefault();

		public static bool IsMuted
		{
			get
			{
				if (!ClientSettings.VoiceChat.Muted.Value)
				{
					return IsDeafened;
				}
				return true;
			}
		}

		public static bool IsDeafened
		{
			get
			{
				if (FusionSceneManager.IsLoading())
				{
					return true;
				}
				if (!ClientSettings.VoiceChat.Deafened.Value)
				{
					return !ServerVoiceEnabled;
				}
				return true;
			}
		}

		public static bool ServerVoiceEnabled => LobbyInfoManager.LobbyInfo.VoiceChat;
	}
	[RegisterTypeInIl2Cpp]
	public class VoiceSource : MonoBehaviour
	{
		private bool _overrideFilter;

		private bool _muted;

		private bool _receivingInput;

		private float _timeSinceInput;

		private bool _wasPlaying;

		[HideFromIl2Cpp]
		public AudioSource AudioSource { get; private set; }

		[HideFromIl2Cpp]
		public AudioStreamFilter StreamFilter { get; private set; }

		public bool OverrideFilter
		{
			get
			{
				return _overrideFilter;
			}
			set
			{
				if (_overrideFilter != value)
				{
					_overrideFilter = value;
					((Behaviour)StreamFilter).enabled = Playing && !value;
				}
			}
		}

		[HideFromIl2Cpp]
		public float Amplitude { get; set; }

		public bool Muted
		{
			get
			{
				return _muted;
			}
			set
			{
				if (_muted != value)
				{
					_muted = value;
					ProcessPlaying();
				}
			}
		}

		public bool ReceivingInput
		{
			get
			{
				return _receivingInput;
			}
			set
			{
				if (_receivingInput != value)
				{
					_receivingInput = value;
					_timeSinceInput = 0f;
					ProcessPlaying();
				}
			}
		}

		public float TimeSinceInput => _timeSinceInput;

		public bool Playing
		{
			get
			{
				if (ReceivingInput)
				{
					return !Muted;
				}
				return false;
			}
		}

		public int ID { get; set; } = -1;


		[HideFromIl2Cpp]
		public static event Action<VoiceSource> OnVoiceEnabled;

		[HideFromIl2Cpp]
		public static event Action<VoiceSource> OnVoiceDisabled;

		public VoiceSource(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			GetAudioSource();
			StopSources();
		}

		private void OnEnable()
		{
			VoiceSource.OnVoiceEnabled?.Invoke(this);
			ReceivingInput = false;
			((Behaviour)StreamFilter).enabled = true;
			((Behaviour)StreamFilter).enabled = false;
		}

		private void OnDisable()
		{
			VoiceSource.OnVoiceDisabled?.Invoke(this);
			ReceivingInput = false;
			((Behaviour)StreamFilter).enabled = false;
		}

		private void Update()
		{
			if (Playing)
			{
				float deltaTime = Time.deltaTime;
				StreamFilter.TickPeak(deltaTime);
				if (StreamFilter.ReadingQueue.Count <= 0)
				{
					_timeSinceInput += deltaTime;
				}
				if (_timeSinceInput > 1f)
				{
					ReceivingInput = false;
				}
			}
		}

		[HideFromIl2Cpp]
		private void ProcessPlaying()
		{
			if (_wasPlaying != Playing)
			{
				_wasPlaying = Playing;
				if (Playing)
				{
					PlaySources();
				}
				else
				{
					StopSources();
				}
			}
		}

		private void PlaySources()
		{
			((Behaviour)StreamFilter).enabled = !OverrideFilter;
			AudioSource.Play();
			Amplitude = 0f;
		}

		private void StopSources()
		{
			AudioSource.Stop();
			((Behaviour)StreamFilter).enabled = false;
			StreamFilter.ClearValues();
			Amplitude = 0f;
		}

		[HideFromIl2Cpp]
		private void GetAudioSource()
		{
			AudioSource component = ((Component)this).GetComponent<AudioSource>();
			if ((Object)(object)component != (Object)null)
			{
				AudioSource = component;
			}
			else
			{
				AudioSource = CreateAudioSource();
			}
			SetSourceSettings();
		}

		[HideFromIl2Cpp]
		private AudioSource CreateAudioSource()
		{
			AudioSource obj = ((Component)this).gameObject.AddComponent<AudioSource>();
			obj.volume = 1f;
			obj.spatialBlend = 1f;
			obj.dopplerLevel = 0.5f;
			obj.spread = 60f;
			return obj;
		}

		[HideFromIl2Cpp]
		private void SetSourceSettings()
		{
			AudioSource.loop = true;
			AudioSource.playOnAwake = false;
			AudioSource.outputAudioMixerGroup = LocalAudioPlayer.Vocals;
			AudioSource.bypassReverbZones = true;
			AudioSource.reverbZoneMix = 0f;
			StreamFilter = ((Component)this).gameObject.AddComponent<AudioStreamFilter>();
			AudioSource.clip = AudioInfo.CreateToneClip();
		}
	}
	public static class VoiceSourceManager
	{
		public static List<VoiceSource> ActiveVoices { get; } = new List<VoiceSource>();


		public static IEnumerable<VoiceSource> GetVoicesByID(int id)
		{
			return ActiveVoices.Where((VoiceSource voice) => voice.ID == id);
		}

		public static void EnqueueSample(IEnumerable<VoiceSource> sources, float sample)
		{
			foreach (VoiceSource source in sources)
			{
				try
				{
					source.StreamFilter.Enqueue(sample);
				}
				catch (Exception e)
				{
					FusionLogger.LogException("enqueueing VoiceSource sample", e);
				}
			}
		}

		public static void SetAmplitude(IEnumerable<VoiceSource> sources, float amplitude)
		{
			foreach (VoiceSource source in sources)
			{
				try
				{
					source.ReceivingInput = true;
					source.Amplitude = amplitude;
				}
				catch (Exception e)
				{
					FusionLogger.LogException("setting VoiceSource amplitude", e);
				}
			}
		}

		public static VoiceSource CreateVoiceSource(int id)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			return CreateVoiceSource(new GameObject($"Voice Source {id}"), id);
		}

		public static VoiceSource CreateVoiceSource(GameObject gameObject, int id)
		{
			VoiceSource voiceSource = gameObject.AddComponent<VoiceSource>();
			voiceSource.ID = id;
			return voiceSource;
		}

		internal static void OnInitializeMelon()
		{
			VoiceSource.OnVoiceEnabled += OnVoiceEnabled;
			VoiceSource.OnVoiceDisabled += OnVoiceDisabled;
		}

		private static void OnVoiceEnabled(VoiceSource source)
		{
			ActiveVoices.Add(source);
		}

		private static void OnVoiceDisabled(VoiceSource source)
		{
			ActiveVoices.RemoveAll((VoiceSource s) => (Object)(object)s == (Object)(object)source);
		}
	}
	public static class VoiceVolume
	{
		public const float DefaultSampleMultiplier = 10f;

		public const float MinimumVoiceVolume = 0.3f;

		public const float SilencingVolume = 0.1f;

		public const float TalkTimeoutTime = 1f;

		public static float GetVolumeMultiplier()
		{
			return ClientSettings.VoiceChat.GlobalVolume.Value;
		}
	}
}
namespace LabFusion.Voice.Unity
{
	public static class UnityVoice
	{
		public const int ClipLength = 1;

		private static bool _hasMicrophones;

		private static bool _checkedForMic;

		private static bool CheckForMicrophone()
		{
			try
			{
				_ = ((Il2CppArrayBase<string>)(object)Microphone.devices)[0];
				return true;
			}
			catch
			{
				return false;
			}
		}

		public static bool IsSupported()
		{
			if (!_checkedForMic)
			{
				_hasMicrophones = CheckForMicrophone();
				_checkedForMic = true;
			}
			return _hasMicrophones;
		}
	}
	public sealed class UnityVoiceManager : VoiceManager
	{
		public override bool CanTalk
		{
			get
			{
				if (!UnityVoice.IsSupported())
				{
					return false;
				}
				return true;
			}
		}

		public override string[] InputDevices
		{
			get
			{
				if (!UnityVoice.IsSupported())
				{
					return Array.Empty<string>();
				}
				return Il2CppArrayBase<string>.op_Implicit((Il2CppArrayBase<string>)(object)Microphone.devices);
			}
		}

		protected override IVoiceReceiver OnCreateReceiverOrDefault()
		{
			return new UnityVoiceReceiver();
		}

		protected override IVoiceSpeaker OnCreateSpeaker(PlayerID id)
		{
			return new UnityVoiceSpeaker(id);
		}
	}
	public sealed class UnityVoiceReceiver : IVoiceReceiver
	{
		private static readonly float[] SampleBuffer = new float[AudioInfo.OutputSampleRate];

		private byte[] _encodedData;

		private bool _hasVoiceActivity;

		private AudioClip _voiceClip;

		private int _lastSample;

		private float _amplitude;

		private float _lastTalkTime;

		private bool _loopedData;

		public float GetVoiceAmplitude()
		{
			return _amplitude;
		}

		public byte[] GetEncodedData()
		{
			return _encodedData;
		}

		public bool HasVoiceActivity()
		{
			return _hasVoiceActivity;
		}

		public static string GetValidMicrophoneName()
		{
			return ClientSettings.VoiceChat.InputDevice.Value;
		}

		private void ClearData()
		{
			_encodedData = null;
			_hasVoiceActivity = false;
			_amplitude = 0f;
		}

		public void UpdateVoice(bool enabled)
		{
			if (!UnityVoice.IsSupported())
			{
				ClearData();
				return;
			}
			string validMicrophoneName = GetValidMicrophoneName();
			if (Microphone.GetMicrophoneDeviceIDFromName(validMicrophoneName) == -1)
			{
				ClearData();
				return;
			}
			bool flag = Microphone.IsRecording(validMicrophoneName);
			if (enabled && !flag)
			{
				_voiceClip = Microphone.Start(validMicrophoneName, true, 1, AudioInfo.OutputSampleRate);
			}
			else if (!enabled && flag)
			{
				Microphone.End(validMicrophoneName);
			}
			if (!enabled || (Object)(object)_voiceClip == (Object)null)
			{
				ClearData();
				return;
			}
			int num = Microphone.GetPosition(validMicrophoneName);
			if (num < _lastSample)
			{
				_loopedData = true;
				num = AudioInfo.OutputSampleRate;
			}
			int num2 = num - _lastSample;
			if (num2 <= 0)
			{
				_hasVoiceActivity = false;
				return;
			}
			Il2CppStructArray<float> val = new Il2CppStructArray<float>((long)num2);
			_voiceClip.GetData(val, _lastSample);
			IntPtr pointer = ((Il2CppObjectBase)val).Pointer;
			int size = IntPtr.Size;
			if (_loopedData)
			{
				_lastSample = 0;
				_loopedData = false;
			}
			else
			{
				_lastSample = num;
			}
			float[] array = new float[num2];
			InteropUtilities.Copy(pointer, size, num2, array);
			bool isTalking = false;
			_amplitude = 0f;
			for (int i = 0; i < num2; i++)
			{
				float num3 = array[i] * 10f;
				SampleBuffer[i] = num3;
				_amplitude += System.Math.Abs(num3);
				if (!isTalking)
				{
					isTalking = System.Math.Abs(num3) >= 0.3f;
				}
			}
			if (num2 > 0)
			{
				_amplitude /= num2;
			}
			CheckTalkingTimeout(ref isTalking);
			_hasVoiceActivity = isTalking;
			if (!isTalking)
			{
				_amplitude = 0f;
				_encodedData = null;
				return;
			}
			SendToSources(SampleBuffer, num2);
			short[] array2 = new short[num2];
			VoiceConverter.CopySamples(array, array2, num2);
			_encodedData = VoiceConverter.Encode(array2);
		}

		private static void SendToSources(float[] buffer, int sampleCount)
		{
			IEnumerable<VoiceSource> voicesByID = VoiceSourceManager.GetVoicesByID(PlayerIDManager.LocalSmallID);
			if (voicesByID.Any())
			{
				float volumeMultiplier = VoiceVolume.GetVolumeMultiplier();
				float num = volumeMultiplier * volumeMultiplier;
				float num2 = 0f;
				for (int i = 0; i < sampleCount; i++)
				{
					float num3 = buffer[i] * num;
					VoiceSourceManager.EnqueueSample(voicesByID, num3);
					num2 += System.Math.Abs(num3);
				}
				if (sampleCount > 0)
				{
					num2 /= (float)sampleCount;
				}
				VoiceSourceManager.SetAmplitude(voicesByID, num2);
			}
		}

		private void CheckTalkingTimeout(ref bool isTalking)
		{
			if (isTalking)
			{
				_lastTalkTime = TimeReferences.TimeSinceStartup;
			}
			else
			{
				isTalking = TimeReferences.TimeSinceStartup - _lastTalkTime <= 1f;
			}
		}

		public void Enable()
		{
		}

		public void Disable()
		{
			_encodedData = null;
			_hasVoiceActivity = false;
		}
	}
	public class UnityVoiceSpeaker : VoiceSpeaker
	{
		public override float Amplitude { get; set; }

		public UnityVoiceSpeaker(PlayerID id)
		{
			_id = id;
			ContactsList.OnContactUpdated += OnContactUpdated;
			OnContactUpdated(ContactsList.GetContact(id));
		}

		public override void Cleanup()
		{
			ContactsList.OnContactUpdated -= OnContactUpdated;
		}

		private void OnContactUpdated(Contact contact)
		{
			if (contact.id == _id.PlatformID)
			{
				base.Volume = contact.volume;
			}
		}

		public override void OnVoiceDataReceived(byte[] data)
		{
			short[] array = VoiceConverter.Decode(data);
			int num = array.Length;
			float[] array2 = new float[num];
			VoiceConverter.CopySamples(array, array2, num);
			float num2 = VoiceVolume.GetVolumeMultiplier() * base.Volume;
			float num3 = num2 * num2;
			float num4 = 0f;
			IEnumerable<VoiceSource> voicesByID = VoiceSourceManager.GetVoicesByID(base.ID.SmallID);
			for (int i = 0; i < num; i++)
			{
				float num5 = array2[i] * num3 * 10f;
				VoiceSourceManager.EnqueueSample(voicesByID, num5);
				num4 += System.Math.Abs(num5);
			}
			if (num > 0)
			{
				num4 /= (float)num;
			}
			Amplitude = num4;
			VoiceSourceManager.SetAmplitude(voicesByID, num4);
		}
	}
}
namespace LabFusion.Utilities
{
	public static class AssemblyUtilities
	{
		public static bool IsValid(this Assembly assembly)
		{
			if (assembly.FullName.Contains("System"))
			{
				return false;
			}
			return true;
		}

		public static bool IsValid(this Type type)
		{
			if (type.Name.Contains("Mono") && type.Name.Contains("Security"))
			{
				return false;
			}
			return true;
		}

		public static void LoadAllValid<T>(Assembly assembly, Action<Type> runOnValid)
		{
			if (!assembly.IsValid())
			{
				return;
			}
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				if (type.IsValid() && typeof(T).IsAssignableFrom(type) && !type.IsAbstract && !type.IsInterface)
				{
					try
					{
						runOnValid(type);
					}
					catch (Exception ex)
					{
						FusionLogger.Error(ex.Message);
					}
				}
			}
		}
	}
	public static class ConstrainerUtilities
	{
		private static Action _constrainerCreatedCallback;

		public const string ConstrainerAssetGUID = "bf9c97bf88c22dc4f981578e75d9aa12";

		public static bool PlayerConstraintsEnabled => LobbyInfoManager.LobbyInfo.PlayerConstraining;

		public static bool HasConstrainer => (Object)(object)GlobalConstrainer != (Object)null;

		public static Constrainer GlobalConstrainer { get; private set; }

		public static void OnMainSceneInitialized()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			SpawnableCrate crate = CrateFilterer.GetCrate<SpawnableCrate>(((ScannableReference)BacklotReferences.ConstrainerReference).Barcode);
			if (!((Object)(object)crate == (Object)null))
			{
				if (!((Crate)crate).Pallet.IsInMarrowGame())
				{
					((Crate)crate).MainAsset = new MarrowAsset("bf9c97bf88c22dc4f981578e75d9aa12");
				}
				Action<GameObject> action = OnConstrainerLoaded;
				((CrateT<GameObject>)(object)crate).LoadAsset(Action<GameObject>.op_Implicit(action));
			}
		}

		private static void OnConstrainerLoaded(GameObject go)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)go == (Object)null)
			{
				_constrainerCreatedCallback = null;
				return;
			}
			GameObject obj = Object.Instantiate<GameObject>(go, new Vector3(1000f, 1000f, 1000f), QuaternionExtensions.identity);
			GlobalConstrainer = obj.GetComponent<Constrainer>();
			obj.SetActive(false);
			_constrainerCreatedCallback?.InvokeSafe("executing Constrainer Created callback");
			_constrainerCreatedCallback = null;
		}

		public static void HookConstrainerCreated(Action callback)
		{
			if (HasConstrainer)
			{
				callback?.Invoke();
			}
			else
			{
				_constrainerCreatedCallback = (Action)Delegate.Combine(_constrainerCreatedCallback, callback);
			}
		}
	}
	public static class DelayUtilities
	{
		private class FrameDelayInfo
		{
			public Action Action;

			public int Counter;
		}

		private static readonly List<FrameDelayInfo> _delays = new List<FrameDelayInfo>();

		public static void InvokeDelayed(Action action, int frames)
		{
			_delays.Add(new FrameDelayInfo
			{
				Action = action,
				Counter = frames
			});
		}

		public static void InvokeNextFrame(Action action)
		{
			InvokeDelayed(action, 1);
		}

		internal static void OnProcessDelays()
		{
			for (int num = _delays.Count - 1; num >= 0; num--)
			{
				FrameDelayInfo frameDelayInfo = _delays[num];
				if (frameDelayInfo.Counter <= 0)
				{
					try
					{
						frameDelayInfo.Action();
					}
					catch (Exception ex)
					{
						FusionLogger.Error(ex.ToString());
					}
					_delays.RemoveAt(num);
				}
				else
				{
					frameDelayInfo.Counter--;
				}
			}
		}
	}
	public static class DllTools
	{
		[DllImport("kernel32", CharSet = CharSet.Unicode, SetLastError = true)]
		public static extern IntPtr LoadLibrary(string lpLibFileName);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
		public static extern bool FreeLibrary(IntPtr hModule);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
		public static extern uint GetLastError();
	}
	public readonly struct FrameBool
	{
		private readonly bool _value;

		private readonly int _frame;

		public bool Value
		{
			get
			{
				if (_value)
				{
					return Valid;
				}
				return false;
			}
		}

		public int Frame => _frame;

		public bool Valid => TimeReferences.FrameCount == Frame;

		public FrameBool(bool value)
		{
			_value = value;
			_frame = TimeReferences.FrameCount;
		}

		public static implicit operator bool(FrameBool value)
		{
			return value.Value;
		}

		public static implicit operator FrameBool(bool value)
		{
			return new FrameBool(value);
		}
	}
	public class FusionComponentCache<TSource, TComponent> where TSource : Object where TComponent : class
	{
		private readonly Dictionary<TSource, TComponent> _cache = new Dictionary<TSource, TComponent>((IEqualityComparer<TSource>?)new UnityComparer());

		public ICollection<TComponent> Components => _cache.Values;

		public TComponent Get(TSource source)
		{
			if (_cache.TryGetValue(source, out var value))
			{
				return value;
			}
			return null;
		}

		public bool TryGet(TSource source, out TComponent value)
		{
			return _cache.TryGetValue(source, out value);
		}

		public bool ContainsSource(TSource source)
		{
			return _cache.ContainsKey(source);
		}

		public void Add(TSource source, TComponent component)
		{
			if (_cache.ContainsKey(source))
			{
				_cache[source] = component;
			}
			else
			{
				_cache.Add(source, component);
			}
		}

		public void Remove(TSource source)
		{
			_cache.Remove(source);
		}
	}
	public static class FusionDevTools
	{
		public static bool DevToolsDisabled
		{
			get
			{
				if (GamemodeManager.IsGamemodeStarted && GamemodeManager.ActiveGamemode.DisableDevTools)
				{
					return true;
				}
				return false;
			}
		}

		public static bool DespawnConstrainer(PlayerID id)
		{
			FusionPermissions.FetchPermissionLevel(id, out var level, out var _);
			if (!FusionPermissions.HasSufficientPermissions(level, LobbyInfoManager.LobbyInfo.Constrainer))
			{
				return true;
			}
			return false;
		}

		public static bool DespawnDevTool(PlayerID id)
		{
			if (DevToolsDisabled)
			{
				return true;
			}
			FusionPermissions.FetchPermissionLevel(id, out var level, out var _);
			if (!FusionPermissions.HasSufficientPermissions(level, LobbyInfoManager.LobbyInfo.DevTools))
			{
				return true;
			}
			return false;
		}

		public static bool PreventSpawnGun(PlayerID id)
		{
			if (GamemodeManager.IsGamemodeStarted && GamemodeManager.ActiveGamemode.DisableSpawnGun)
			{
				return true;
			}
			FusionPermissions.FetchPermissionLevel(id, out var level, out var _);
			if (!FusionPermissions.HasSufficientPermissions(level, LobbyInfoManager.LobbyInfo.DevTools))
			{
				return true;
			}
			return false;
		}
	}
	internal static class FusionLogger
	{
		internal static void LogLine([CallerLineNumber] int lineNumber = 0)
		{
			Log($"FusionLogger.LogLine is only for debugging! Please remove from line {lineNumber}", ConsoleColor.Red);
		}

		internal static void Log(string txt, ConsoleColor txt_color = ConsoleColor.White)
		{
			((MelonBase)FusionMod.Instance).LoggerInstance.Msg(txt_color, txt);
		}

		internal static void Log(object obj, ConsoleColor txt_color = ConsoleColor.White)
		{
			((MelonBase)FusionMod.Instance).LoggerInstance.Msg(txt_color, obj);
		}

		internal static void Warn(string txt)
		{
			((MelonBase)FusionMod.Instance).LoggerInstance.Warning(txt);
		}

		internal static void Warn(object obj)
		{
			((MelonBase)FusionMod.Instance).LoggerInstance.Warning(obj);
		}

		internal static void Error(string txt)
		{
			((MelonBase)FusionMod.Instance).LoggerInstance.Error(txt);
		}

		internal static void ErrorLine(string txt, [CallerLineNumber] int lineNumber = 0)
		{
			((MelonBase)FusionMod.Instance).LoggerInstance.Error($"{txt} - Line: {lineNumber}");
		}

		internal static void Error(object obj)
		{
			((MelonBase)FusionMod.Instance).LoggerInstance.Error(obj);
		}

		internal static void LogException(string task, Exception e)
		{
			if (e.InnerException != null)
			{
				e = e.InnerException;
			}
			Error($"Failed {task} with reason: {e.Message}\nTrace:{e.StackTrace}");
		}
	}
	public delegate bool UserOverride(PlayerID id);
	public static class FusionOverrides
	{
		private static UserOverride _onValidateNametag;

		public static event UserOverride OnValidateNametag
		{
			add
			{
				_onValidateNametag = (UserOverride)Delegate.Combine(_onValidateNametag, value);
				ForceUpdateOverrides();
			}
			remove
			{
				_onValidateNametag = (UserOverride)Delegate.Remove(_onValidateNametag, value);
				ForceUpdateOverrides();
			}
		}

		public static event Action OnOverridesChanged;

		public static bool ValidateNametag(PlayerID id)
		{
			if (_onValidateNametag == null)
			{
				return true;
			}
			Delegate[] invocationList = _onValidateNametag.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				if (!((UserOverride)invocationList[i])(id))
				{
					return false;
				}
			}
			return true;
		}

		public static void ForceUpdateOverrides()
		{
			FusionOverrides.OnOverridesChanged.InvokeSafe("executing OnOverridesChanged");
		}
	}
	public static class FusionPlayer
	{
		public static readonly List<Transform> SpawnPoints = new List<Transform>();

		private static bool _brokeBounds = false;

		public static byte? LastAttacker { get; internal set; }

		internal static void OnMainSceneInitialized()
		{
			LastAttacker = null;
			if (_brokeBounds)
			{
				Physics.autoSimulation = true;
				_brokeBounds = false;
			}
		}

		internal static void OnUpdate()
		{
			if (!FusionSceneManager.IsLoading() && RigData.HasPlayer)
			{
				CheckFloatingPoint();
			}
		}

		private static void CheckFloatingPoint()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkTransformManager.IsInBounds(RigData.Refs.RigManager.physicsRig.feet.transform.position))
			{
				Physics.autoSimulation = false;
				_brokeBounds = true;
				if (NetworkInfo.HasServer && !NetworkInfo.IsHost)
				{
					NetworkHelper.Disconnect("Left Bounds");
				}
				SceneStreamer.Reload();
				Notifier.Send(new Notification
				{
					ShowPopup = true,
					Title = "Whoops! Sorry about that!",
					Type = NotificationType.WARNING,
					Message = "The scene was reloaded due to being sent far out of bounds.",
					PopupLength = 6f
				});
			}
		}

		public static bool TryGetLastAttacker(out PlayerID id)
		{
			id = null;
			if (!LastAttacker.HasValue)
			{
				return false;
			}
			id = PlayerIDManager.GetPlayerID(LastAttacker.Value);
			return id != null;
		}

		public static bool IsLocalPlayer(this RigManager rigManager)
		{
			if (!RigData.HasPlayer)
			{
				return true;
			}
			return (Object)(object)rigManager == (Object)(object)RigData.Refs.RigManager;
		}

		public static void SetSpawnPoints(params Transform[] points)
		{
			SpawnPoints.Clear();
			SpawnPoints.AddRange(points);
		}

		public static void ResetSpawnPoints()
		{
			SpawnPoints.Clear();
		}

		public static bool TryGetSpawnPoint(out Transform point)
		{
			point = null;
			SpawnPoints.RemoveAll((Transform t) => (Object)(object)t == (Object)null);
			if (SpawnPoints.Count > 0)
			{
				point = SpawnPoints.GetRandom();
				return true;
			}
			return false;
		}
	}
	public delegate bool UserAccessEvent(PlayerID playerId, out string reason);
	public delegate void ServerEvent();
	public delegate void UpdateEvent();
	public delegate void PlayerUpdate(PlayerID playerId);
	public delegate void PlayerAction(PlayerID playerId, PlayerActionType type, PlayerID otherPlayer = null);
	public static class MultiplayerHooking
	{
		public static event UserAccessEvent OnShouldAllowConnection;

		public static event ServerEvent OnStartedServer;

		public static event ServerEvent OnJoinedServer;

		public static event ServerEvent OnDisconnected;

		public static event PlayerUpdate OnPlayerJoined;

		public static event PlayerUpdate OnPlayerLeft;

		public static event PlayerAction OnPlayerAction;

		public static event UpdateEvent OnUpdate;

		public static event UpdateEvent OnFixedUpdate;

		public static event UpdateEvent OnLateUpdate;

		public static event UpdateEvent OnMainSceneInitialized;

		public static event UpdateEvent OnLoadingBegin;

		public static event UpdateEvent OnTargetLevelLoaded;

		internal static bool CheckShouldAllowConnection(PlayerID playerId, out string reason)
		{
			reason = "";
			if (MultiplayerHooking.OnShouldAllowConnection == null)
			{
				return true;
			}
			Delegate[] invocationList = MultiplayerHooking.OnShouldAllowConnection.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				if (!((UserAccessEvent)invocationList[i])(playerId, out reason))
				{
					return false;
				}
			}
			return true;
		}

		internal static void InvokeOnStartedServer()
		{
			MultiplayerHooking.OnStartedServer.InvokeSafe("executing OnStartedServer hook");
		}

		internal static void InvokeOnJoinedServer()
		{
			MultiplayerHooking.OnJoinedServer.InvokeSafe("executing OnJoinedServer hook");
		}

		internal static void InvokeOnDisconnected()
		{
			MultiplayerHooking.OnDisconnected.InvokeSafe("executing OnDisconnected hook");
		}

		internal static void InvokeOnPlayerJoined(PlayerID id)
		{
			MultiplayerHooking.OnPlayerJoined.InvokeSafe(id, "executing OnPlayerJoined hook");
		}

		internal static void InvokeOnPlayerLeft(PlayerID id)
		{
			MultiplayerHooking.OnPlayerLeft.InvokeSafe(id, "executing OnPlayerLeft hook");
		}

		internal static void InvokeOnPlayerAction(PlayerID id, PlayerActionType type, PlayerID otherPlayer = null)
		{
			MultiplayerHooking.OnPlayerAction.InvokeSafe(id, type, otherPlayer, "executing OnPlayerAction hook");
		}

		internal static void InvokeOnUpdate()
		{
			MultiplayerHooking.OnUpdate?.Invoke();
		}

		internal static void InvokeOnFixedUpdate()
		{
			MultiplayerHooking.OnFixedUpdate?.Invoke();
		}

		internal static void InvokeOnLateUpdate()
		{
			MultiplayerHooking.OnLateUpdate?.Invoke();
		}

		internal static void InvokeOnMainSceneInitialized()
		{
			MultiplayerHooking.OnMainSceneInitialized.InvokeSafe("executing OnMainSceneInitialized hook");
		}

		internal static void InvokeOnLoadingBegin()
		{
			MultiplayerHooking.OnLoadingBegin.InvokeSafe("executing OnLoadingBegin hook");
		}

		internal static void InvokeTargetLevelLoaded()
		{
			MultiplayerHooking.OnTargetLevelLoaded.InvokeSafe("executing OnTargetLevelLoaded hook");
		}
	}
	public static class GameObjectUtilities
	{
		private static readonly List<GameObject> _rootObjectBuffer = new List<GameObject>();

		internal static List<GameObject> FindRootsWithName(string scene, string name)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			Scene sceneByName = SceneManager.GetSceneByName(scene);
			if (!((Scene)(ref sceneByName)).IsValid())
			{
				return null;
			}
			_rootObjectBuffer.Capacity = ((Scene)(ref sceneByName)).rootCount;
			((Scene)(ref sceneByName)).GetRootGameObjects(_rootObjectBuffer);
			_rootObjectBuffer.RemoveAll(Predicate<GameObject>.op_Implicit((Func<GameObject, bool>)((GameObject g) => ((Object)g).name != name)));
			return _rootObjectBuffer;
		}

		internal static int GetRootIndex(this GameObject go)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			Scene scene = go.scene;
			return FindRootsWithName(((Scene)(ref scene)).name, ((Object)go).name).FindIndex(Predicate<GameObject>.op_Implicit((Func<GameObject, bool>)((GameObject g) => (Object)(object)g == (Object)(object)go)));
		}

		internal static GameObject GetRootByIndex(string scene, int index, string name)
		{
			List<GameObject> val = FindRootsWithName(scene, name);
			if (val == null || val.Count == 0)
			{
				return GameObject.Find("/" + name);
			}
			if (val.Count <= index)
			{
				return val[val.Count - 1];
			}
			return val[index];
		}

		public static string GetFullPath(this GameObject go)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(0, 4);
				Scene scene = go.scene;
				defaultInterpolatedStringHandler.AppendFormatted(((Scene)(ref scene)).name);
				defaultInterpolatedStringHandler.AppendFormatted('¬');
				defaultInterpolatedStringHandler.AppendFormatted(((Component)go.transform.root).gameObject.GetRootIndex());
				defaultInterpolatedStringHandler.AppendFormatted(go.transform.GetBasePath());
				return defaultInterpolatedStringHandler.ToStringAndClear();
			}
			catch
			{
			}
			return "INVALID_PATH";
		}

		public static GameObject GetGameObject(string path)
		{
			string[] array = path.Split('¬');
			string scene = array[0];
			int index = int.Parse(array[1]);
			string name = array[2];
			try
			{
				GameObject rootByIndex = GetRootByIndex(scene, index, name);
				if ((Object)(object)rootByIndex != (Object)null)
				{
					Transform val = rootByIndex.transform;
					for (int i = 3; i < array.Length; i++)
					{
						val = val.GetTransformByIndex(int.Parse(array[i++]), array[i]);
					}
					return ((Component)val).gameObject;
				}
			}
			catch (Exception)
			{
			}
			return null;
		}
	}
	public static class ImpactUtilities
	{
		public static void OnHitRigidbody(Rigidbody rb)
		{
			GameObject gameObject = ((Component)rb).gameObject;
			MarrowBody marrowBody = MarrowBody.Cache.Get(gameObject);
			if ((Object)(object)marrowBody == (Object)null)
			{
				return;
			}
			if (MarrowBodyExtender.Cache.TryGet(marrowBody, out var value))
			{
				if (!value.IsOwnerLocked)
				{
					GripExtender extender = value.GetExtender<GripExtender>();
					if (extender == null || !extender.CheckHeld())
					{
						NetworkEntityManager.TakeOwnership(value);
					}
				}
			}
			else
			{
				DelayUtilities.InvokeDelayed(delegate
				{
					PropSender.SendPropCreation(marrowBody.Entity);
				}, 4);
			}
		}
	}
	internal static class PersistentAssetCreator
	{
		private const string _targetFont = "arlon-medium";

		private static Action<HandPose> _onSoftGrabLoaded;

		internal static TMP_FontAsset Font { get; private set; }

		internal static HandPose SoftGrabPose { get; private set; }

		internal static void OnLateInitializeMelon()
		{
			CreateTextFont();
		}

		internal static void OnMainSceneInitialized()
		{
			GetHandPose();
		}

		private static void GetHandPose()
		{
			if (RigData.HasPlayer)
			{
				SoftGrabPose = RigData.Refs.RigManager.worldGripHandPose;
			}
			if ((Object)(object)SoftGrabPose != (Object)null)
			{
				_onSoftGrabLoaded?.Invoke(SoftGrabPose);
			}
			_onSoftGrabLoaded = null;
		}

		public static void HookOnSoftGrabLoaded(Action<HandPose> action)
		{
			if ((Object)(object)SoftGrabPose != (Object)null)
			{
				action?.Invoke(SoftGrabPose);
			}
			else
			{
				_onSoftGrabLoaded = (Action<HandPose>)Delegate.Combine(_onSoftGrabLoaded, action);
			}
		}

		private static void CreateTextFont()
		{
			Il2CppArrayBase<TMP_FontAsset> val = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			foreach (TMP_FontAsset item in val)
			{
				if (((Object)item).name.ToLower().Contains("arlon-medium"))
				{
					Font = item;
					break;
				}
			}
			if ((Object)(object)Font == (Object)null)
			{
				Font = val[0];
			}
		}

		internal static void SetupImpactProperties(RigManager rig)
		{
			PhysicsRig physicsRig = rig.physicsRig;
			Il2CppArrayBase<Rigidbody> componentsInChildren = ((Component)physicsRig).GetComponentsInChildren<Rigidbody>(true);
			SurfaceData surfaceData = physicsRig._surfaceDataDefault;
			Avatar avatar = rig.avatar;
			if ((Object)(object)avatar != (Object)null && Object.op_Implicit((Object)(object)avatar.surfaceData))
			{
				surfaceData = avatar.surfaceData;
			}
			List<ImpactProperties> list = new List<ImpactProperties>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Rigidbody obj = componentsInChildren[i];
				GameObject gameObject = ((Component)obj).gameObject;
				if (!Object.op_Implicit((Object)(object)((Component)obj).GetComponent<ImpactProperties>()) && !((Object)(object)gameObject == (Object)(object)physicsRig.knee) && !((Object)(object)gameObject == (Object)(object)physicsRig.feet))
				{
					ImpactProperties val = gameObject.AddComponent<ImpactProperties>();
					val.surfaceData = surfaceData;
					val.decalType = (DecalType)(-1);
					list.Add(val);
				}
			}
			physicsRig._impactProperties = new Il2CppReferenceArray<ImpactProperties>(list.ToArray());
		}
	}
	internal static class SafeEvents
	{
		internal static void InvokeSafe<T>(this T action, string task) where T : Delegate
		{
			if ((Delegate?)action == (Delegate?)null)
			{
				return;
			}
			Delegate[] invocationList = action.GetInvocationList();
			foreach (Delegate @delegate in invocationList)
			{
				try
				{
					@delegate.DynamicInvoke();
				}
				catch (Exception e)
				{
					FusionLogger.LogException(task, e);
				}
			}
		}

		internal static void InvokeSafe<T, T1>(this T action, T1 param, string task) where T : Delegate
		{
			if ((Delegate?)action == (Delegate?)null)
			{
				return;
			}
			Delegate[] invocationList = action.GetInvocationList();
			foreach (Delegate @delegate in invocationList)
			{
				try
				{
					@delegate.DynamicInvoke(param);
				}
				catch (Exception e)
				{
					FusionLogger.LogException(task, e);
				}
			}
		}

		internal static void InvokeSafe<T, T1, T2>(this T action, T1 param1, T2 param2, string task) where T : Delegate
		{
			if ((Delegate?)action == (Delegate?)null)
			{
				return;
			}
			Delegate[] invocationList = action.GetInvocationList();
			foreach (Delegate @delegate in invocationList)
			{
				try
				{
					@delegate.DynamicInvoke(param1, param2);
				}
				catch (Exception e)
				{
					FusionLogger.LogException(task, e);
				}
			}
		}

		internal static void InvokeSafe<T, T1, T2, T3>(this T action, T1 param1, T2 param2, T3 param3, string task) where T : Delegate
		{
			if ((Delegate?)action == (Delegate?)null)
			{
				return;
			}
			Delegate[] invocationList = action.GetInvocationList();
			foreach (Delegate @delegate in invocationList)
			{
				try
				{
					@delegate.DynamicInvoke(param1, param2, param3);
				}
				catch (Exception e)
				{
					FusionLogger.LogException(task, e);
				}
			}
		}
	}
	public static class InteropUtilities
	{
		public unsafe static void FloatArrayFastWrite(IntPtr pointer, int size, int index, float value)
		{
			*(float*)((byte*)IntPtr.Add(pointer, 4 * size).ToPointer() + (nint)index * (nint)4) = value;
		}

		public unsafe static float FloatArrayFastRead(IntPtr pointer, int size, int index)
		{
			return *(float*)((byte*)IntPtr.Add(pointer, 4 * size).ToPointer() + (nint)index * (nint)4);
		}

		public static void Copy(IntPtr pointer, int size, int length, float[] array)
		{
			for (int i = 0; i < length; i++)
			{
				array[i] = FloatArrayFastRead(pointer, size, i);
			}
		}
	}
	public static class MagazineUtilities
	{
		public static void ClaimMagazine(Magazine magazine, InventoryAmmoReceiver ammoReceiver)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			CartridgeData val = ammoReceiver.defaultLightCart;
			if ((Object)(object)ammoReceiver._selectedCartridgeData != (Object)null)
			{
				val = ammoReceiver._selectedCartridgeData;
			}
			if ((Object)(object)val != (Object)null && (Object)(object)val.projectile != (Object)null)
			{
				ProjectileEmitter.Register(val.projectile);
			}
			magazine.Initialize(val, AmmoInventory.Instance.GetCartridgeCount(val));
			magazine.Claim();
			LocalAudioPlayer.PlayAtPoint(Il2CppArrayBase<AudioClip>.op_Implicit((Il2CppArrayBase<AudioClip>)(object)ammoReceiver.grabClips), ((Component)ammoReceiver).transform.position, new AudioPlayerSettings
			{
				Mixer = LocalAudioPlayer.SoftInteraction,
				Volume = 0.2f
			});
		}

		public static void GrabMagazine(Magazine magazine, NetworkPlayer player, Handedness handedness)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			player.HookOnReady(OnPlayerReady);
			void OnPlayerReady()
			{
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Invalid comparison between Unknown and I4
				RigManager rigManager = player.RigRefs.RigManager;
				InventoryAmmoReceiverExtender extender = player.NetworkEntity.GetExtender<InventoryAmmoReceiverExtender>();
				if (extender != null)
				{
					ClaimMagazine(magazine, extender.Component);
				}
				Grip grip = magazine.grip;
				Hand found = (((int)handedness == 0) ? null : (((int)handedness == 1) ? rigManager.physicsRig.leftHand : rigManager.physicsRig.rightHand));
				if (Object.op_Implicit((Object)(object)found))
				{
					DelayUtilities.InvokeNextFrame(delegate
					{
						grip.MoveIntoHand(found);
						grip.TryAttach(found, isInstant: true);
					});
				}
			}
		}
	}
	public static class MuteUIHelper
	{
		private static PageItem _mutePage;

		private static Poolee _indicatorPoolee;

		private static GameObject _indicatorGameObject;

		private static Renderer _indicatorRenderer;

		private static Camera _headsetCamera;

		public const string NotificationTag = "Mute";

		public static void OnInitializeMelon()
		{
			FusionPref<bool> muted = ClientSettings.VoiceChat.Muted;
			muted.OnValueChanged = (Action<bool>)Delegate.Combine(muted.OnValueChanged, new Action<bool>(OnMutedChanged));
			FusionPref<bool> mutedIndicator = ClientSettings.VoiceChat.MutedIndicator;
			mutedIndicator.OnValueChanged = (Action<bool>)Delegate.Combine(mutedIndicator.OnValueChanged, new Action<bool>(OnIndicatorChanged));
			RenderPipelineManager.beginCameraRendering += Action<ScriptableRenderContext, Camera>.op_Implicit((Action<ScriptableRenderContext, Camera>)OnBeginCameraRendering);
			RenderPipelineManager.endCameraRendering += Action<ScriptableRenderContext, Camera>.op_Implicit((Action<ScriptableRenderContext, Camera>)OnEndCameraRendering);
		}

		public static void OnDeinitializeMelon()
		{
			FusionPref<bool> muted = ClientSettings.VoiceChat.Muted;
			muted.OnValueChanged = (Action<bool>)Delegate.Remove(muted.OnValueChanged, new Action<bool>(OnMutedChanged));
			FusionPref<bool> mutedIndicator = ClientSettings.VoiceChat.MutedIndicator;
			mutedIndicator.OnValueChanged = (Action<bool>)Delegate.Remove(mutedIndicator.OnValueChanged, new Action<bool>(OnIndicatorChanged));
			RenderPipelineManager.beginCameraRendering -= Action<ScriptableRenderContext, Camera>.op_Implicit((Action<ScriptableRenderContext, Camera>)OnBeginCameraRendering);
			RenderPipelineManager.endCameraRendering -= Action<ScriptableRenderContext, Camera>.op_Implicit((Action<ScriptableRenderContext, Camera>)OnEndCameraRendering);
		}

		private static void OnBeginCameraRendering(ScriptableRenderContext context, Camera camera)
		{
			if (!((Object)(object)camera != (Object)(object)_headsetCamera) && !((Object)(object)_indicatorRenderer == (Object)null))
			{
				_indicatorRenderer.enabled = true;
			}
		}

		private static void OnEndCameraRendering(ScriptableRenderContext context, Camera camera)
		{
			if (!((Object)(object)camera != (Object)(object)_headsetCamera) && !((Object)(object)_indicatorRenderer == (Object)null))
			{
				_indicatorRenderer.enabled = false;
			}
		}

		private static void OnMutedChanged(bool value)
		{
			if (_mutePage != null)
			{
				_mutePage.name = (value ? "Quick Unmute" : "Quick Mute");
			}
			UpdateMuteIcon();
		}

		private static void OnIndicatorChanged(bool value)
		{
			UpdateMuteIcon();
		}

		private static void UpdateMuteIcon()
		{
			if (!((Object)(object)_indicatorGameObject == (Object)null))
			{
				_indicatorGameObject.SetActive(VoiceInfo.ShowMuteIndicator);
			}
		}

		public static void OnCreateMuteUI(RigManager manager)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if (!VoiceInfo.CanTalk)
			{
				return;
			}
			PopUpMenuView popUpMenu = UIRig.Instance.popUpMenu;
			Page homePage = popUpMenu.radialPageView.m_HomePage;
			FusionPref<bool> mutedPref = ClientSettings.VoiceChat.Muted;
			_mutePage = new PageItem(mutedPref.Value ? "Quick Unmute" : "Quick Mute", (Directions)3, Action.op_Implicit((Action)delegate
			{
				mutedPref.Value = !mutedPref.Value;
				popUpMenu.Deactivate();
				Notifier.Cancel("Mute");
				Notifier.Send(new Notification
				{
					ShowPopup = true,
					SaveToMenu = false,
					Message = (mutedPref.Value ? "Muted" : "Unmuted"),
					Tag = "Mute"
				});
			}));
			homePage.items.Add(_mutePage);
			OpenControllerRig val = ((Il2CppObjectBase)manager.ControllerRig).TryCast<OpenControllerRig>();
			Transform headset = val.headset;
			Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.MuteIndicatorReference);
			LocalAssetSpawner.Register(spawnable);
			LocalAssetSpawner.Spawn(spawnable, Vector3.zero, Quaternion.identity, delegate(Poolee poolee)
			{
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				_indicatorPoolee = poolee;
				_indicatorGameObject = ((Component)poolee).gameObject;
				_indicatorGameObject.SetActive(false);
				((Object)_indicatorGameObject).name = "Mute Icon [FUSION]";
				_indicatorRenderer = _indicatorGameObject.GetComponentInChildren<Renderer>();
				_indicatorRenderer.enabled = false;
				if (!((Object)(object)headset == (Object)null))
				{
					_headsetCamera = ((Component)headset).GetComponent<Camera>();
					Transform transform = _indicatorGameObject.transform;
					transform.parent = headset;
					transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
					UpdateMuteIcon();
				}
			});
		}

		public static void OnDestroyMuteUI()
		{
			if (_mutePage != null)
			{
				PopUpMenuView popUpMenu = UIRig.Instance.popUpMenu;
				Page homePage = popUpMenu.radialPageView.m_HomePage;
				homePage.items.RemoveAll(Predicate<PageItem>.op_Implicit((Func<PageItem, bool>)((PageItem i) => i.name == _mutePage.name)));
				popUpMenu.radialPageView.Render(homePage);
				_mutePage = null;
			}
			if ((Object)(object)_indicatorPoolee != (Object)null)
			{
				_indicatorPoolee.Despawn();
				_indicatorPoolee = null;
				_indicatorGameObject = null;
				_indicatorRenderer = null;
			}
		}
	}
	public static class PlatformHelper
	{
		private static readonly bool _isAndroidCached = (int)MelonUtils.CurrentPlatform == 3;

		public const string AndroidName = "QUEST";

		public const string WindowsName = "PC";

		public static bool IsAndroid => _isAndroidCached;

		public static string GetPlatformName()
		{
			if (IsAndroid)
			{
				return "QUEST";
			}
			return "PC";
		}
	}
	public static class PlayerAdditionsHelper
	{
		public static void OnInitializeMelon()
		{
			MultiplayerHooking.OnJoinedServer += delegate
			{
				OnEnterServer(RigData.Refs.RigManager);
			};
			MultiplayerHooking.OnStartedServer += delegate
			{
				OnEnterServer(RigData.Refs.RigManager);
			};
			MultiplayerHooking.OnDisconnected += delegate
			{
				OnExitServer(RigData.Refs.RigManager);
			};
			LocalPlayer.OnLocalRigCreated = (Action<RigManager>)Delegate.Combine(LocalPlayer.OnLocalRigCreated, (Action<RigManager>)delegate(RigManager rig)
			{
				if (NetworkInfo.HasServer)
				{
					OnEnterServer(rig);
				}
			});
			MuteUIHelper.OnInitializeMelon();
		}

		public static void OnDeinitializeMelon()
		{
			MuteUIHelper.OnDeinitializeMelon();
		}

		public static void OnEnterServer(RigManager manager)
		{
			if (!((Object)(object)manager == (Object)null))
			{
				MuteUIHelper.OnCreateMuteUI(manager);
				PersistentAssetCreator.SetupImpactProperties(manager);
				manager.health._testVisualDamage = true;
				Player_Health obj = ((Il2CppObjectBase)manager.health).TryCast<Player_Health>();
				obj.reloadLevelOnDeath = false;
				obj.slowMoOnDeath = false;
				PhysicsRig physicsRig = manager.physicsRig;
				((Component)((Rig)physicsRig).m_handLf).gameObject.AddComponent<CollisionSyncer>();
				((Component)((Rig)physicsRig).m_elbowLf).gameObject.AddComponent<CollisionSyncer>();
				((Component)((Rig)physicsRig).m_shoulderLf).gameObject.AddComponent<CollisionSyncer>();
				((Component)((Rig)physicsRig).m_handRt).gameObject.AddComponent<CollisionSyncer>();
				((Component)((Rig)physicsRig).m_elbowRt).gameObject.AddComponent<CollisionSyncer>();
				((Component)((Rig)physicsRig).m_shoulderRt).gameObject.AddComponent<CollisionSyncer>();
				physicsRig.feet.gameObject.AddComponent<CollisionSyncer>();
				((Component)((Rig)physicsRig).m_head).gameObject.AddComponent<CollisionSyncer>();
			}
		}

		public static void OnExitServer(RigManager manager)
		{
			if ((Object)(object)manager == (Object)null)
			{
				return;
			}
			MuteUIHelper.OnDestroyMuteUI();
			manager.physicsRig._impactProperties = new Il2CppReferenceArray<ImpactProperties>(0L);
			foreach (ImpactProperties componentsInChild in ((Component)manager).GetComponentsInChildren<ImpactProperties>(true))
			{
				Object.Destroy((Object)(object)componentsInChild);
			}
			foreach (CollisionSyncer componentsInChild2 in ((Component)manager).GetComponentsInChildren<CollisionSyncer>(true))
			{
				Object.Destroy((Object)(object)componentsInChild2);
			}
			manager.health._testVisualDamage = false;
			((Il2CppObjectBase)manager.health).TryCast<Player_Health>().slowMoOnDeath = true;
		}
	}
	public static class PooleeUtilities
	{
		public static void DespawnAll()
		{
			if (!NetworkInfo.IsHost)
			{
				return;
			}
			NetworkEntity[] array = NetworkEntityManager.IDManager.RegisteredEntities.EntityIDLookup.Keys.ToArray();
			foreach (NetworkEntity networkEntity in array)
			{
				if (networkEntity.GetExtender<NetworkProp>() != null)
				{
					PooleeExtender extender = networkEntity.GetExtender<PooleeExtender>();
					if (extender != null && !IsFixture(networkEntity))
					{
						extender.Component.Despawn();
					}
				}
			}
		}

		private static bool IsFixture(NetworkEntity entity)
		{
			if (entity.GetExtender<CircuitSocketExtender>() != null)
			{
				return true;
			}
			return false;
		}
	}
	public static class TimeReferences
	{
		public static float DeltaTime { get; private set; } = 1f;


		public static float UnscaledDeltaTime { get; private set; } = 1f;


		public static float FixedDeltaTime { get; private set; } = 0.02f;


		public static float FixedUnscaledDeltaTime { get; private set; } = 0.02f;


		public static float TimeSinceStartup { get; private set; } = 0f;


		public static float TimeScale { get; private set; } = 1f;


		public static int FrameCount { get; private set; } = 0;


		public static void OnEarlyUpdate()
		{
			TimeScale = Time.timeScale;
			DeltaTime = Time.deltaTime;
			UnscaledDeltaTime = Time.unscaledDeltaTime;
			TimeSinceStartup += DeltaTime;
			FrameCount++;
		}

		public static void OnEarlyFixedUpdate()
		{
			FixedDeltaTime = Time.fixedDeltaTime;
			FixedUnscaledDeltaTime = Time.fixedUnscaledDeltaTime;
		}

		public static bool IsMatchingFrame(int interval)
		{
			return FrameCount % interval == 0;
		}

		public static bool IsMatchingFrame(int interval, int offset)
		{
			return (FrameCount + offset) % interval == 0;
		}
	}
	public static class TriggerUtilities
	{
		public static bool IsMatchingRig(TriggerRefProxy proxy, RigManager rig)
		{
			if (!NetworkInfo.HasServer || !RigData.HasPlayer)
			{
				return true;
			}
			RigManager val;
			if (Object.op_Implicit((Object)(object)proxy.root) && Object.op_Implicit((Object)(object)(val = RigManager.Cache.Get(proxy.root))))
			{
				return (Object)(object)val == (Object)(object)rig;
			}
			return false;
		}
	}
	public static class LaserCursorUtilities
	{
		public static void CreateLaserCursor(Action<LaserCursor> onCursorReady = null)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.LaserCursorReference);
			LocalAssetSpawner.Register(spawnable);
			LocalAssetSpawner.Spawn(spawnable, Vector3.zero, Quaternion.identity, delegate(Poolee poolee)
			{
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0111: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: Expected O, but got Unknown
				GameObject gameObject = ((Component)poolee).gameObject;
				Transform transform = gameObject.transform;
				gameObject.SetActive(false);
				LaserCursor cursor = gameObject.AddComponent<LaserCursor>();
				PageElementView val = transform.Find("Arrow").SetupPageElementView();
				PageElementView val2 = transform.Find("ray_start").SetupPageElementView();
				PageElementView val3 = transform.Find("ray_mid").SetupPageElementView();
				PageElementView val4 = transform.Find("ray_mid2").SetupPageElementView();
				PageElementView val5 = transform.Find("ray_bez").SetupPageElementView();
				PageElementView val6 = transform.Find("ray_end").SetupPageElementView();
				PageElementView rayPulse = transform.Find("ray_pulse").SetupPageElementView();
				PageElementView val7 = transform.Find("SFX").SetupPageElementView();
				AnimationCurve blipCurve = (val4.blipCurve = (val3.blipCurve = (val2.blipCurve = new AnimationCurve((Keyframe[])(object)new Keyframe[4]
				{
					new Keyframe(0f, 1f),
					new Keyframe(0.1271991f, 1.953225f),
					new Keyframe(0.724905f, 0.9818711f),
					new Keyframe(1f, 1f)
				}))));
				val6.blipCurve = blipCurve;
				DrawBezierCurve val11 = ((Component)val).gameObject.AddComponent<DrawBezierCurve>();
				val11.Point1 = ((Component)val6).gameObject;
				val11.Point2 = ((Component)val5).gameObject;
				val11.Point3 = ((Component)val3).gameObject;
				val11.Point4 = ((Component)val2).gameObject;
				val11.lineSteps = 12;
				val11.linePercentageFill = 0.73f;
				PrismaticSFX prismaticSFX = ((Component)val7).gameObject.AddComponent<PrismaticSFX>();
				prismaticSFX.velocityTran = ((Component)val7).transform;
				prismaticSFX.sourceTran = ((Component)val7).transform;
				prismaticSFX.minSpeed = 0.2f;
				prismaticSFX.maxSpeed = 4f;
				prismaticSFX.sourceMinDistance = 1f;
				prismaticSFX.pitchMod = 1f;
				prismaticSFX.loopClips = true;
				prismaticSFX.audioEvents = Il2CppReferenceArray<AudioEvent>.op_Implicit(Array.Empty<AudioEvent>());
				prismaticSFX.modulatedClips = Il2CppReferenceArray<AudioClip>.op_Implicit(Array.Empty<AudioClip>());
				AudioLoader.LoadMonoDisc(FusionMonoDiscReferences.LaserPrismaticSFXReference, delegate(AudioClip clip)
				{
					prismaticSFX.modulatedClips = Il2CppReferenceArray<AudioClip>.op_Implicit((AudioClip[])(object)new AudioClip[1] { clip });
				});
				prismaticSFX.SpatialBlend = 0.98f;
				cursor.cursorStart = val2;
				cursor.cursorEnd = val6;
				cursor.cursorMid = val3;
				cursor.cursorMid2 = val4;
				cursor.cursorBez = val5;
				cursor.rayPulse = rayPulse;
				cursor.lineEnd = val;
				cursor.cursorLine = ((Component)val).GetComponent<LineRenderer>();
				cursor.bezCurve = val11;
				cursor.pulseLength = 0.2f;
				cursor.pulseAceleration = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f);
				AudioLoader.LoadMonoDisc(FusionMonoDiscReferences.LaserPulseReference, delegate(AudioClip clip)
				{
					cursor.pulseSound = Il2CppReferenceArray<AudioClip>.op_Implicit((AudioClip[])(object)new AudioClip[1] { clip });
				});
				AudioLoader.LoadMonoDisc(FusionMonoDiscReferences.LaserRaySpawnReference, delegate(AudioClip clip)
				{
					cursor.raySpawn = Il2CppReferenceArray<AudioClip>.op_Implicit((AudioClip[])(object)new AudioClip[1] { clip });
				});
				AudioLoader.LoadMonoDisc(FusionMonoDiscReferences.LaserRayDespawnReference, delegate(AudioClip clip)
				{
					cursor.rayDespawn = Il2CppReferenceArray<AudioClip>.op_Implicit((AudioClip[])(object)new AudioClip[1] { clip });
				});
				cursor.prismaticSFX = prismaticSFX;
				cursor.spatialBlend = 1f;
				cursor._sourceVolume = 0.3f;
				cursor._sourceRadius = 1f;
				cursor.cursorHidden = true;
				cursor.canShowCursor = true;
				cursor.maxMillimeters = 16f;
				onCursorReady?.Invoke(cursor);
			});
		}

		private static PageElementView SetupPageElementView(this Transform transform)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			HighlightUI val = ((Component)transform).gameObject.AddComponent<HighlightUI>();
			val.color1 = new Color(1f, 1f, 1f, 0.1294118f);
			val.color2 = Color.white;
			PageElementView val2 = ((Component)transform).gameObject.AddComponent<PageElementView>();
			val2.highlightColor1 = new Color(1f, 1f, 1f, 0f);
			val2.highlightColor2 = Color.white;
			val2.color1 = new Color(1f, 1f, 1f, 0f);
			val2.color2 = Color.white;
			val2.blipCurve = AnimationCurve.Linear(0f, 1f, 1f, 1f);
			val2.elements = Il2CppReferenceArray<HighlightUI>.op_Implicit((HighlightUI[])(object)new HighlightUI[1] { val });
			return val2;
		}
	}
	public static class UIMachineUtilities
	{
		public static void CreateLaserCursor(Transform canvas, Transform uiPlane, Vector3 bounds)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			LaserCursorUtilities.CreateLaserCursor(delegate(LaserCursor cursor)
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Expected O, but got Unknown
				((Component)cursor).transform.parent = canvas.parent;
				((Component)cursor).transform.SetLocalPositionAndRotation(Vector3Extensions.zero, QuaternionExtensions.identity);
				CursorRegion val = new CursorRegion
				{
					bounds = new Bounds(Vector3Extensions.zero, Vector3.Scale(bounds, canvas.lossyScale)),
					center = uiPlane
				};
				cursor.regions = Il2CppReferenceArray<CursorRegion>.op_Implicit((CursorRegion[])(object)new CursorRegion[1] { val });
				FusionSceneManager.HookOnLevelLoad(delegate
				{
					if (!((Object)(object)cursor == (Object)null))
					{
						((Component)cursor).gameObject.SetActive(true);
					}
				});
			});
		}

		public static void CreateUITrigger(GameObject canvas, GameObject trigger)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			trigger.SetActive(false);
			trigger.layer = 29;
			Zone zone = trigger.AddComponent<Zone>();
			ZoneEvents obj = trigger.AddComponent<ZoneEvents>();
			((ZoneItem)obj)._zone = zone;
			obj.onZoneEnter = new ZoneEventCallback();
			obj.onZoneEnterOneShot = new ZoneEventCallback();
			obj.onZoneExit = new ZoneEventCallback();
			TagQuery val = new TagQuery
			{
				BoneTag = MarrowBoneTagReferences.PlayerReference
			};
			((ZoneItem)obj).activatorTags.Tags.Add(val);
			((UltEvent<MarrowEntity>)(object)obj.onZoneEnter).DynamicCalls += Action<MarrowEntity>.op_Implicit((Action<MarrowEntity>)delegate
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				canvas.SetActive(true);
				LocalAudioPlayer.PlayAtPoint(new AudioReference(FusionMonoDiscReferences.UITurnOnReference), canvas.transform.position, LocalAudioPlayer.SFXSettings);
			});
			((UltEvent<MarrowEntity>)(object)obj.onZoneExit).DynamicCalls += Action<MarrowEntity>.op_Implicit((Action<MarrowEntity>)delegate
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				canvas.SetActive(false);
				LocalAudioPlayer.PlayAtPoint(new AudioReference(FusionMonoDiscReferences.UITurnOffReference), canvas.transform.position, LocalAudioPlayer.SFXSettings);
			});
			trigger.SetActive(true);
		}

		public static void OverrideFonts(Transform root)
		{
			foreach (TMP_Text componentsInChild in ((Component)root).GetComponentsInChildren<TMP_Text>(true))
			{
				componentsInChild.font = PersistentAssetCreator.Font;
			}
		}

		public static void AddButtonTriggers(Transform root)
		{
			foreach (Button componentsInChild in ((Component)root).GetComponentsInChildren<Button>(true))
			{
				Collider componentInChildren = ((Component)componentsInChild).GetComponentInChildren<Collider>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((Component)componentInChildren).gameObject.AddComponent<FusionUITrigger>().button = componentsInChild;
				}
			}
		}

		public static void AddClickEvent(this Button button, Action action)
		{
			((UnityEvent)button.onClick).AddListener(UnityAction.op_Implicit(action));
		}
	}
}
namespace LabFusion.UI
{
	[RegisterTypeInIl2Cpp]
	public sealed class CupBoard : FusionUIMachine
	{
		private const float _maxMusicVolume = 0.3f;

		private CupBoardPanelView _panelView;

		private AudioSource[] _musicLayers;

		private int _layerCount;

		private GameObject _completionistGo;

		public CupBoardPanelView PanelView => _panelView;

		public CupBoard(IntPtr intPtr)
			: base(intPtr)
		{
		}

		protected override void OnAwake()
		{
			base.OnAwake();
			_musicLayers = Il2CppArrayBase<AudioSource>.op_Implicit(((Component)((Component)this).transform.Find("SFX/Music")).GetComponentsInChildren<AudioSource>());
			_layerCount = _musicLayers.Length;
			_completionistGo = ((Component)((Component)this).transform.Find("Art/Offset/Completionist")).gameObject;
			LabFusion.SDK.Achievements.Achievement.OnAchievementCompleted += OnAchievementCompleted;
			LoadProgress();
		}

		private void OnDestroy()
		{
			LabFusion.SDK.Achievements.Achievement.OnAchievementCompleted -= OnAchievementCompleted;
		}

		[HideFromIl2Cpp]
		private void OnAchievementCompleted(LabFusion.SDK.Achievements.Achievement achievement)
		{
			LoadProgress();
		}

		private void LoadProgress()
		{
			float achievementProgress = AchievementManager.GetAchievementProgress();
			LoadEffects(achievementProgress);
			LoadMusic(achievementProgress);
			AchievementManager.CheckCompletionistUnlocks();
		}

		private void LoadEffects(float progress)
		{
			bool active = progress >= 1f;
			_completionistGo.SetActive(active);
		}

		private void LoadMusic(float progress)
		{
			_musicLayers[0].volume = 0.3f;
			int num = _layerCount - 1;
			float num2 = progress * (float)num;
			for (int i = 0; i < num; i++)
			{
				float t = num2 - (float)i;
				_musicLayers[i + 1].volume = ManagedMathf.Lerp(0f, 0.3f, t);
			}
		}

		protected override void AddPanelView(GameObject panel)
		{
			_panelView = panel.AddComponent<CupBoardPanelView>();
		}

		protected override Transform GetGripRoot()
		{
			return ((Component)this).transform.Find("Colliders");
		}
	}
	public static class CupBoardHelper
	{
		public static void CompleteAchievementBoard(GameObject gameObject)
		{
			gameObject.AddComponent<CupBoard>();
		}

		public static void SpawnAchievementBoard(Vector3 position, Quaternion rotation)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.AchievementBoardReference);
			LocalAssetSpawner.Register(spawnable);
			LocalAssetSpawner.Spawn(spawnable, position, rotation);
		}
	}
	[RegisterTypeInIl2Cpp]
	public sealed class CupBoardPanelView : FusionPanelView
	{
		private Transform _achievementButtonsRoot;

		private Transform _arrowButtonsRoot;

		private Slider _progressSlider;

		private TMP_Text _progressText;

		private Transform[] _achievementPanels;

		private int _achievementButtonCount;

		private int _currentPageIndex;

		private int _pageCount;

		private Texture _defaultPreview;

		private TMP_Text _pageCountText;

		protected override Vector3 Bounds => new Vector3(2.14f, 1.4f, 0.1f);

		public int PageCount => _pageCount;

		[HideFromIl2Cpp]
		public IReadOnlyList<LabFusion.SDK.Achievements.Achievement> PageItems => AchievementManager.GetSortedAchievements();

		public CupBoardPanelView(IntPtr intPtr)
			: base(intPtr)
		{
		}

		protected override void OnAwake()
		{
			base.OnAwake();
			SetupArrows();
			LabFusion.SDK.Achievements.Achievement.OnAchievementUpdated += OnAchievementUpdated;
			MenuResources.HookResourcesReady(LoadPage);
		}

		private void OnDestroy()
		{
			LabFusion.SDK.Achievements.Achievement.OnAchievementUpdated -= OnAchievementUpdated;
		}

		[HideFromIl2Cpp]
		private void OnAchievementUpdated(LabFusion.SDK.Achievements.Achievement achievement)
		{
			LoadPage();
		}

		protected override void OnSetupReferences()
		{
			_achievementButtonsRoot = _canvas.Find("achievement_Buttons");
			_arrowButtonsRoot = _canvas.Find("arrow_Buttons");
			_progressSlider = ((Component)_canvas.Find("bar_Progress")).GetComponent<Slider>();
			_progressText = ((Component)((Component)_progressSlider).transform.Find("text")).GetComponent<TMP_Text>();
			_pageCountText = ((Component)_arrowButtonsRoot.Find("button_pageCount")).GetComponentInChildren<TMP_Text>();
			_achievementButtonCount = _achievementButtonsRoot.childCount;
			_achievementPanels = (Transform[])(object)new Transform[_achievementButtonCount];
			for (int i = 0; i < _achievementButtonCount; i++)
			{
				_achievementPanels[i] = _achievementButtonsRoot.GetChild(i);
				if (i == 0)
				{
					_defaultPreview = ((Component)_achievementPanels[i]).GetComponentInChildren<RawImage>().texture;
				}
			}
		}

		private void SetupArrows()
		{
			((Component)_arrowButtonsRoot.Find("button_lastPage")).GetComponent<Button>().AddClickEvent(delegate
			{
				LastPage();
			});
			((Component)_arrowButtonsRoot.Find("button_nextPage")).GetComponent<Button>().AddClickEvent(delegate
			{
				NextPage();
			});
		}

		public void NextPage()
		{
			_currentPageIndex++;
			if (_currentPageIndex >= PageCount)
			{
				_currentPageIndex = PageCount - 1;
			}
			LoadPage();
		}

		public void LastPage()
		{
			_currentPageIndex--;
			if (_currentPageIndex < 0)
			{
				_currentPageIndex = 0;
			}
			LoadPage();
		}

		private void LoadPage()
		{
			if (PageItems.Count <= 0)
			{
				_pageCount = 0;
			}
			else
			{
				_pageCount = (int)System.Math.Ceiling((double)PageItems.Count / (double)_achievementButtonCount);
			}
			_currentPageIndex = ManagedMathf.Clamp(_currentPageIndex, 0, PageCount);
			_pageCountText.text = $"Page {_currentPageIndex + 1} out of {System.Math.Max(1, PageCount)}";
			for (int i = 0; i < _achievementButtonCount; i++)
			{
				Transform val = _achievementPanels[i];
				int achievementIndex = GetAchievementIndex(i);
				if (PageItems.Count <= achievementIndex)
				{
					((Component)val).gameObject.SetActive(false);
					continue;
				}
				((Component)val).gameObject.SetActive(true);
				LoadAchievement(val, PageItems[achievementIndex]);
			}
			LoadProgress();
		}

		private void LoadProgress()
		{
			float achievementProgress = AchievementManager.GetAchievementProgress();
			_progressSlider.Set(achievementProgress, false);
			_progressText.text = $"{achievementProgress * 100f}%";
		}

		[HideFromIl2Cpp]
		private void LoadAchievement(Transform transform, LabFusion.SDK.Achievements.Achievement achievement)
		{
			TMP_Text component = ((Component)transform.Find("title")).GetComponent<TMP_Text>();
			TMP_Text component2 = ((Component)transform.Find("description")).GetComponent<TMP_Text>();
			TMP_Text component3 = ((Component)transform.Find("progress")).GetComponent<TMP_Text>();
			RawImage component4 = ((Component)transform.Find("icon")).GetComponent<RawImage>();
			GameObject gameObject = ((Component)transform.Find("completed")).gameObject;
			GameObject gameObject2 = ((Component)transform.Find("incompleted")).gameObject;
			TMP_Text component5 = ((Component)component.transform.Find("button_bitCount").Find("text")).GetComponent<TMP_Text>();
			component.text = achievement.Title;
			component2.text = achievement.Description;
			component5.text = achievement.BitReward.ToString();
			component3.text = achievement.Progress;
			if ((Object)(object)achievement.Logo != (Object)null)
			{
				component4.texture = achievement.Logo;
			}
			else
			{
				component4.texture = _defaultPreview;
			}
			gameObject.SetActive(achievement.IsComplete);
			gameObject2.SetActive(!achievement.IsComplete);
		}

		private int GetAchievementIndex(int index)
		{
			return index + _currentPageIndex * _achievementButtonCount;
		}
	}
	public class FusionPanelView : MonoBehaviour
	{
		protected Transform _canvas;

		protected Transform _uiPlane;

		protected virtual Vector3 Bounds => new Vector3(1f, 1f, 0.1f);

		public FusionPanelView(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			UIMachineUtilities.OverrideFonts(((Component)this).transform);
			UIMachineUtilities.AddButtonTriggers(((Component)this).transform);
			SetupReferences();
			OnAwake();
			((Component)_canvas).gameObject.SetActive(false);
		}

		private void SetupReferences()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			_canvas = ((Component)this).transform.Find("CANVAS");
			_uiPlane = _canvas.Find("UIPLANE");
			UIMachineUtilities.CreateLaserCursor(_canvas, _uiPlane, Bounds);
			OnSetupReferences();
		}

		protected virtual void OnAwake()
		{
		}

		protected virtual void OnSetupReferences()
		{
		}
	}
	public class FusionUIMachine : MonoBehaviour
	{
		public FusionUIMachine(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			PersistentAssetCreator.HookOnSoftGrabLoaded(delegate(HandPose p)
			{
				foreach (Collider componentsInChild in ((Component)GetGripRoot()).GetComponentsInChildren<Collider>())
				{
					if (!Object.op_Implicit((Object)(object)Grip.Cache.Get(((Component)componentsInChild).gameObject)))
					{
						GenericGrip obj = ((Component)componentsInChild).gameObject.AddComponent<GenericGrip>();
						((Grip)obj).isThrowable = true;
						((Grip)obj).ignoreGripTargetOnAttach = false;
						((Grip)obj).additionalGripColliders = Il2CppReferenceArray<Collider>.op_Implicit((Collider[])(object)new Collider[0]);
						((Grip)obj).handleAmplifyCurve = AnimationCurve.Linear(0f, 1f, 0f, 1f);
						((Grip)obj).gripOptions = (InteractionOptions)1;
						((Grip)obj).priority = 1f;
						((Grip)obj).handPose = p;
						((Grip)obj).minBreakForce = float.PositiveInfinity;
						((Grip)obj).maxBreakForce = float.PositiveInfinity;
						((Grip)obj).defaultGripDistance = float.PositiveInfinity;
						((Grip)obj).radius = 0.24f;
					}
				}
				foreach (Rigidbody componentsInChild2 in ((Component)((Component)this).transform).GetComponentsInChildren<Rigidbody>())
				{
					((Component)componentsInChild2).gameObject.AddComponent<InteractableHost>();
				}
			});
			Transform val = ((Component)this).transform.Find("PANELVIEW");
			AddPanelView(((Component)val).gameObject);
			UIMachineUtilities.CreateUITrigger(((Component)val.Find("CANVAS")).gameObject, ((Component)((Component)this).transform.Find("uiTrigger")).gameObject);
			AudioSource[] array = Il2CppArrayBase<AudioSource>.op_Implicit(((Component)this).gameObject.GetComponentsInChildren<AudioSource>(true));
			for (int i = 0; i < array.Length; i++)
			{
				array[i].outputAudioMixerGroup = Audio3dManager.diegeticMusic;
			}
			OnAwake();
		}

		protected virtual void OnAwake()
		{
		}

		protected virtual void AddPanelView(GameObject panel)
		{
		}

		protected virtual Transform GetGripRoot()
		{
			return null;
		}
	}
	[RegisterTypeInIl2Cpp]
	public sealed class FusionUITrigger : MonoBehaviour
	{
		public Button button;

		public FusionUITrigger(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			EventTrigger obj = ((Component)this).gameObject.AddComponent<EventTrigger>();
			Entry val = new Entry
			{
				eventID = (EventTriggerType)4
			};
			((UnityEvent<BaseEventData>)(object)val.callback).AddListener(UnityAction<BaseEventData>.op_Implicit((Action<BaseEventData>)delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				LocalAudioPlayer.PlayAtPoint(new AudioReference(FusionMonoDiscReferences.UIConfirmReference), ((Component)this).transform.position, LocalAudioPlayer.SFXSettings);
				ButtonClickedEvent onClick = button.onClick;
				if (onClick != null)
				{
					((UnityEvent)onClick).Invoke();
				}
			}));
			Entry val2 = new Entry
			{
				eventID = (EventTriggerType)0
			};
			((UnityEvent<BaseEventData>)(object)val2.callback).AddListener(UnityAction<BaseEventData>.op_Implicit((Action<BaseEventData>)delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				LocalAudioPlayer.PlayAtPoint(new AudioReference(FusionMonoDiscReferences.UISelectReference), ((Component)this).transform.position, LocalAudioPlayer.SFXSettings);
			}));
			obj.delegates.Add(val);
			obj.delegates.Add(val2);
		}
	}
	[RegisterTypeInIl2Cpp]
	public sealed class InfoBox : FusionUIMachine
	{
		private InfoBoxPanelView _panelView;

		public InfoBoxPanelView PanelView => _panelView;

		public InfoBox(IntPtr intPtr)
			: base(intPtr)
		{
		}

		protected override void AddPanelView(GameObject panel)
		{
			_panelView = panel.AddComponent<InfoBoxPanelView>();
		}

		protected override Transform GetGripRoot()
		{
			return ((Component)this).transform.Find("Colliders");
		}
	}
	public static class InfoBoxHelper
	{
		public static void CompleteInfoBoard(GameObject gameObject)
		{
			gameObject.AddComponent<InfoBox>();
		}

		public static void SpawnInfoBoard(Vector3 position, Quaternion rotation)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.InfoBoardReference);
			LocalAssetSpawner.Register(spawnable);
			LocalAssetSpawner.Spawn(spawnable, position, rotation);
		}
	}
	[RegisterTypeInIl2Cpp]
	public sealed class InfoBoxPanelView : FusionPanelView
	{
		private TMP_Text _versionText;

		private TMP_Text _changelogText;

		private TMP_Text _credits01Text;

		private TMP_Text _credits02Text;

		private TMP_Text _credits03Text;

		private Transform _groupPatchNotes;

		private Transform _groupCredits;

		private Transform _groupMystery;

		private Button _patchNotesButton;

		private Button _creditsButton;

		private Button _mysteryButton;

		protected override Vector3 Bounds => new Vector3(0.64f, 0.64f, 0.1f);

		public InfoBoxPanelView(IntPtr intPtr)
			: base(intPtr)
		{
		}

		protected override void OnAwake()
		{
			SetupButtons();
			LoadPage(((Component)_groupPatchNotes).gameObject);
		}

		protected override void OnSetupReferences()
		{
			_versionText = ((Component)_canvas.Find("text_versionNumber")).GetComponent<TMP_Text>();
			_versionText.text = $"v{FusionMod.Version}";
			_groupPatchNotes = _canvas.Find("group_patchNotes");
			_groupCredits = _canvas.Find("group_credits");
			_groupMystery = _canvas.Find("group_mystery");
			_changelogText = ((Component)_groupPatchNotes.Find("button_changelogContents")).GetComponentInChildren<TMP_Text>();
			_changelogText.text = FusionMod.Changelog;
			_credits01Text = ((Component)_groupCredits.Find("text_credits01")).GetComponentInChildren<TMP_Text>();
			_credits02Text = ((Component)_groupCredits.Find("text_credits02")).GetComponentInChildren<TMP_Text>();
			_credits03Text = ((Component)_groupCredits.Find("text_credits03")).GetComponentInChildren<TMP_Text>();
			if (FusionMod.Credits != null)
			{
				_credits01Text.text = FusionMod.Credits[0];
				_credits02Text.text = FusionMod.Credits[1];
				_credits03Text.text = FusionMod.Credits[2];
			}
			_patchNotesButton = ((Component)_canvas.Find("button_patchNotes")).GetComponent<Button>();
			_creditsButton = ((Component)_canvas.Find("button_credits")).GetComponent<Button>();
			_mysteryButton = ((Component)_canvas.Find("button_mystery")).GetComponent<Button>();
		}

		private void SetupButtons()
		{
			_patchNotesButton.AddClickEvent(delegate
			{
				LoadPage(((Component)_groupPatchNotes).gameObject);
			});
			_creditsButton.AddClickEvent(delegate
			{
				LoadPage(((Component)_groupCredits).gameObject);
			});
			_mysteryButton.AddClickEvent(delegate
			{
				if (AchievementManager.TryGetAchievement<HelloThere>(out var achievement))
				{
					achievement.IncrementTask();
				}
				LoadPage(((Component)_groupMystery).gameObject);
			});
		}

		private void LoadPage(GameObject page)
		{
			((Component)_groupPatchNotes).gameObject.SetActive(false);
			((Component)_groupCredits).gameObject.SetActive(false);
			((Component)_groupMystery).gameObject.SetActive(false);
			page.SetActive(true);
		}
	}
	public interface IPopupLayoutElement
	{
		int Priority { get; }

		Transform Transform { get; }

		bool Visible { get; set; }

		void Spawn(Transform parent);

		void Despawn();
	}
}
namespace LabFusion.UI.Popups
{
	public static class AchievementPopup
	{
		public const float DefaultDuration = 5f;

		public static readonly Vector3 LocalPosition = new Vector3(0f, -0.06f, 0.9f);

		private static readonly Queue<LabFusion.SDK.Achievements.Achievement> _queuedAchievements = new Queue<LabFusion.SDK.Achievements.Achievement>();

		private static float _timeOfPopup = 0f;

		public static void Send(LabFusion.SDK.Achievements.Achievement achievement)
		{
			QueueAchievement(achievement);
		}

		private static void QueueAchievement(LabFusion.SDK.Achievements.Achievement achievement)
		{
			_queuedAchievements.Enqueue(achievement);
		}

		private static void DequeueAchievement()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			_timeOfPopup = TimeReferences.TimeSinceStartup;
			LabFusion.SDK.Achievements.Achievement achievement = _queuedAchievements.Dequeue();
			Transform camera = ((Rig)RigData.Refs.ControllerRig).m_head;
			Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.AchievementPopupReference);
			LocalAssetSpawner.Register(spawnable);
			LocalAssetSpawner.Spawn(spawnable, Vector3.zero, Quaternion.identity, delegate(Poolee poolee)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				Transform transform = ((Component)poolee).transform;
				transform.parent = camera;
				UIMachineUtilities.OverrideFonts(((Component)transform).transform);
				transform.localPosition = LocalPosition;
				transform.localRotation = Quaternion.identity;
				Transform val = transform.Find("Offset/Canvas");
				if ((Object)(object)achievement.Logo != (Object)null)
				{
					((Component)val.Find("icon")).GetComponent<RawImage>().texture = achievement.Logo;
				}
				((Component)val.Find("title")).GetComponent<TMP_Text>().text = achievement.Title;
				((Component)val.Find("description")).GetComponent<TMP_Text>().text = achievement.Description;
				LocalAudioPlayer.Play2dOneShot(new AudioReference(FusionMonoDiscReferences.UITurnOnReference), LocalAudioPlayer.InHeadSettings);
				PooleeHelper.DespawnDelayed(poolee, 5.1f);
			});
		}

		internal static bool IsPlayingPopup()
		{
			return TimeReferences.TimeSinceStartup - _timeOfPopup <= 5.1f;
		}

		internal static void OnInitializeMelon()
		{
			LabFusion.SDK.Achievements.Achievement.OnAchievementCompleted += Send;
		}

		internal static void OnUpdate()
		{
			if (_queuedAchievements.Count > 0 && FusionSceneManager.HasTargetLoaded() && !FusionSceneManager.IsDelayedLoading() && RigData.HasPlayer && !IsPlayingPopup())
			{
				DequeueAchievement();
			}
		}
	}
	public static class BitPopup
	{
		private static readonly Queue<int> _bitQueue = new Queue<int>();

		public const float DefaultDuration = 1f;

		public static readonly Vector3 LocalPosition = new Vector3(0.319f, -0.198f, 0.783f);

		public static readonly Quaternion LocalRotation = Quaternion.Euler(0f, 17.252f, 0f);

		internal static void OnUpdate()
		{
			if (FusionSceneManager.HasTargetLoaded() && !FusionSceneManager.IsDelayedLoading() && RigData.HasPlayer && _bitQueue.Count > 0)
			{
				DequeueBit();
			}
		}

		public static void Send(int amount)
		{
			if (amount != 0)
			{
				_bitQueue.Enqueue(amount);
			}
		}

		private static void DequeueBit()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			int amount = _bitQueue.Dequeue();
			Transform camera = ((Rig)RigData.Refs.ControllerRig).m_head;
			Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.BitPopupReference);
			LocalAssetSpawner.Register(spawnable);
			LocalAssetSpawner.Spawn(spawnable, Vector3.zero, Quaternion.identity, delegate(Poolee poolee)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				Transform transform = ((Component)poolee).transform;
				transform.parent = camera;
				UIMachineUtilities.OverrideFonts(transform);
				transform.SetLocalPositionAndRotation(LocalPosition, LocalRotation);
				Transform obj = transform.Find("Offset/Canvas");
				string text = ((amount < 0) ? $"{amount}" : $"+{amount}");
				((Component)obj.Find("text_shadow")).GetComponent<TMP_Text>().text = text;
				TMP_Text component = ((Component)obj.Find("amount")).GetComponent<TMP_Text>();
				component.text = text;
				Color color = Color.white;
				if (amount < 0)
				{
					color = Color.red;
				}
				((Graphic)component).color = color;
				((Graphic)((Component)obj.Find("bit")).GetComponent<RawImage>()).color = color;
				LocalAudioPlayer.Play2dOneShot(new AudioReference(FusionMonoDiscReferences.BitGetReference), LocalAudioPlayer.InHeadSettings);
				PooleeHelper.DespawnDelayed(poolee, 1.1f);
			});
		}
	}
	public class Notification
	{
		public NotificationText Title { get; set; } = new NotificationText("New Notification");


		public NotificationText Message { get; set; }

		public string Tag { get; set; }

		public bool ShowPopup { get; set; } = true;


		public float PopupLength { get; set; } = 2f;


		public NotificationType Type { get; set; }

		public bool SaveToMenu { get; set; } = true;


		public Action OnAccepted { get; set; }

		public Action OnDeclined { get; set; }
	}
	public struct NotificationText
	{
		public string Text { get; set; }

		public Color Color { get; set; }

		public bool RichText { get; set; }

		public NotificationText(string text)
			: this(text, Color.white)
		{
		}//IL_0002: Unknown result type (might be due to invalid IL or missing references)


		public NotificationText(string text, Color color, bool richText = false)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (!richText)
			{
				text = text.RemoveRichText();
			}
			Text = text;
			Color = color;
			RichText = richText;
		}

		public static implicit operator NotificationText(string text)
		{
			return new NotificationText(text);
		}
	}
	public enum NotificationType
	{
		INFORMATION,
		WARNING,
		ERROR,
		SUCCESS
	}
	public static class Notifier
	{
		public const float DefaultDuration = 2f;

		public const float DefaultScaleTime = 0.4f;

		private static readonly List<Notification> _queuedNotifications = new List<Notification>();

		private static Notification _currentNotification = null;

		private static bool _hasEnabledTutorialRig = false;

		public static Notification CurrentNotification => _currentNotification;

		public static List<Notification> GetNotificationsByTag(string tag)
		{
			List<Notification> list = new List<Notification>();
			foreach (Notification queuedNotification in _queuedNotifications)
			{
				if (queuedNotification.Tag == tag)
				{
					list.Add(queuedNotification);
				}
			}
			if (CurrentNotification != null && CurrentNotification.Tag == tag)
			{
				list.Add(CurrentNotification);
			}
			return list;
		}

		public static List<Notification> GetAllNotifications()
		{
			List<Notification> list = new List<Notification>();
			list.AddRange(_queuedNotifications);
			if (CurrentNotification != null)
			{
				list.Add(CurrentNotification);
			}
			return list;
		}

		public static void Send(Notification notification)
		{
			QueueNotification(notification);
		}

		public static void Cancel(Notification notification)
		{
			if (_queuedNotifications.Contains(notification))
			{
				_queuedNotifications.Remove(notification);
			}
			if (CurrentNotification == notification)
			{
				_currentNotification = null;
				StopHeadTitles();
			}
		}

		public static void Cancel(string tag)
		{
			foreach (Notification item in GetNotificationsByTag(tag))
			{
				Cancel(item);
			}
		}

		public static void CancelAll()
		{
			foreach (Notification allNotification in GetAllNotifications())
			{
				Cancel(allNotification);
			}
		}

		private static void QueueNotification(Notification notification)
		{
			_queuedNotifications.Add(notification);
			if (notification.SaveToMenu)
			{
				MenuNotifications.AddNotification(notification);
			}
		}

		private static void DequeueNotification()
		{
			_currentNotification = _queuedNotifications[0];
			_queuedNotifications.RemoveAt(0);
			if (CurrentNotification.ShowPopup && RigData.HasPlayer)
			{
				HeadTitles headTitles = TutorialRig.Instance.headTitles;
				EnableTutorialRig();
				string text = CurrentNotification.Title.Text;
				string text2 = CurrentNotification.Message.Text;
				Sprite val = GetPopupSprite(CurrentNotification) ?? headTitles.defaultElementSprite;
				float popupLength = CurrentNotification.PopupLength;
				float timeToScale = Mathf.Lerp(0.05f, 0.4f, Mathf.Clamp01(popupLength - 1f));
				headTitles.timeToScale = timeToScale;
				headTitles.CUSTOMDISPLAY(text, text2, val, popupLength, (AudioClip)null, false, (Sprite)null, (Sprite)null, (Sprite)null, (Sprite)null);
				headTitles.sr_element.sprite = val;
			}
		}

		private static Sprite GetPopupSprite(Notification notification)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if (!MenuResources.HasResources)
			{
				return null;
			}
			Texture2D val = (Texture2D)(notification.Type switch
			{
				NotificationType.WARNING => ((Il2CppObjectBase)MenuResources.GetNotificationIcon("Warning")).TryCast<Texture2D>(), 
				NotificationType.ERROR => ((Il2CppObjectBase)MenuResources.GetNotificationIcon("Error")).TryCast<Texture2D>(), 
				NotificationType.SUCCESS => ((Il2CppObjectBase)MenuResources.GetNotificationIcon("Success")).TryCast<Texture2D>(), 
				_ => ((Il2CppObjectBase)MenuResources.GetNotificationIcon("Information")).TryCast<Texture2D>(), 
			});
			if ((Object)(object)val != (Object)null)
			{
				return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			}
			return null;
		}

		internal static void EnableTutorialRig()
		{
			if (RigData.HasPlayer)
			{
				TutorialRig instance = TutorialRig.Instance;
				HeadTitles headTitles = instance.headTitles;
				((Component)instance).gameObject.SetActive(true);
				((Component)headTitles).gameObject.SetActive(true);
			}
		}

		internal static bool IsPlayingNotification()
		{
			if (!RigData.HasPlayer)
			{
				return false;
			}
			return ((Component)TutorialRig.Instance.headTitles.headFollower).gameObject.activeInHierarchy;
		}

		private static void StopHeadTitles()
		{
			if (RigData.HasPlayer)
			{
				TutorialRig instance = TutorialRig.Instance;
				if (!((Object)(object)instance == (Object)null))
				{
					instance.headTitles.CLOSEDISPLAY();
				}
			}
		}

		internal static void OnUpdate()
		{
			if (_queuedNotifications.Count > 0 && !FusionSceneManager.IsLoading() && RigData.HasPlayer)
			{
				if (!_hasEnabledTutorialRig)
				{
					EnableTutorialRig();
					_hasEnabledTutorialRig = true;
				}
				else if (!IsPlayingNotification())
				{
					_currentNotification = null;
					if (_queuedNotifications.Count > 0)
					{
						DequeueNotification();
					}
				}
			}
			else
			{
				_hasEnabledTutorialRig = false;
			}
		}
	}
	public static class PopupManager
	{
		internal static void OnInitializeMelon()
		{
			AchievementPopup.OnInitializeMelon();
		}

		internal static void OnUpdate()
		{
			Notifier.OnUpdate();
			AchievementPopup.OnUpdate();
			BitPopup.OnUpdate();
		}
	}
}
namespace LabFusion.Support
{
	public static class GameInfo
	{
		private static readonly string _gameNameCached = Application.productName;

		public static string GameName => _gameNameCached;
	}
	public static class SupportGameNames
	{
		public static readonly string BonelabName = "BONELAB";
	}
	public static class SupportManager
	{
		public static readonly Dictionary<string, string> GameToModule = new Dictionary<string, string> { 
		{
			SupportGameNames.BonelabName,
			SupportResourcePaths.BonelabSupportPath
		} };

		public static void LoadGameModule(Assembly assembly)
		{
			if (GameToModule.TryGetValue(GameInfo.GameName, out var value))
			{
				Assembly assembly2 = EmbeddedResource.LoadAssemblyFromAssembly(assembly, value);
				if (!(assembly2 == null))
				{
					ModuleManager.LoadModules(assembly2);
				}
			}
		}
	}
	public static class SupportResourcePaths
	{
		public static readonly string SupportFolder = "LabFusion.SupportModules";

		public static readonly string BonelabSupportPath = SupportFolder + ".BonelabSupport.dll";
	}
}
namespace LabFusion.Senders
{
	public static class GamemodeSender
	{
		public static void SendGamemodeTriggerResponse(string gamemodeBarcode, string name, string value = null)
		{
			MessageRelay.RelayNative(new GamemodeTriggerResponseData
			{
				GamemodeBarcode = gamemodeBarcode,
				TriggerName = name,
				TriggerValue = value
			}, NativeMessageTag.GamemodeTriggerResponse, CommonMessageRoutes.ReliableToClients);
		}

		public static void SendGamemodeMetadataSet(string gamemodeBarcode, string key, string value)
		{
			if (NetworkInfo.IsHost)
			{
				MessageRelay.RelayNative(new GamemodeMetadataSetData
				{
					GamemodeBarcode = gamemodeBarcode,
					Key = key,
					Value = value
				}, NativeMessageTag.GamemodeMetadataSet, CommonMessageRoutes.ReliableToClients);
			}
		}

		public static void SendGamemodeMetadataRemove(string gamemodeBarcode, string key)
		{
			if (NetworkInfo.IsHost)
			{
				MessageRelay.RelayNative(new GamemodeMetadataRemoveData
				{
					GamemodeBarcode = gamemodeBarcode,
					Key = key
				}, NativeMessageTag.GamemodeMetadataRemove, CommonMessageRoutes.ReliableToClients);
			}
		}
	}
	public static class PointItemSender
	{
		public static void SendPointItemEquip(string barcode, bool isEquipped)
		{
			if (NetworkInfo.HasServer)
			{
				MessageRelay.RelayNative(new PointItemEquipStateData
				{
					Barcode = barcode,
					IsEquipped = isEquipped
				}, NativeMessageTag.PointItemEquipState, CommonMessageRoutes.ReliableToOtherClients);
			}
		}

		public static void SendPointItemTrigger(string barcode)
		{
			if (NetworkInfo.HasServer)
			{
				MessageRelay.RelayNative(new PointItemTriggerData
				{
					Barcode = barcode
				}, NativeMessageTag.PointItemTrigger, CommonMessageRoutes.ReliableToOtherClients);
			}
		}

		public static void SendPointItemTrigger(string barcode, string value)
		{
			if (NetworkInfo.HasServer)
			{
				MessageRelay.RelayNative(new PointItemTriggerValueData
				{
					Barcode = barcode,
					Value = value
				}, NativeMessageTag.PointItemTriggerValue, CommonMessageRoutes.ReliableToOtherClients);
			}
		}
	}
	public enum PlayerActionType
	{
		UNKNOWN,
		JUMP,
		DEATH,
		DYING,
		DEALT_DAMAGE_TO_OTHER_PLAYER,
		DYING_BY_OTHER_PLAYER,
		RECOVERY,
		DEATH_BY_OTHER_PLAYER,
		RESPAWN
	}
	public enum NicknameVisibility
	{
		SHOW = 1,
		SHOW_WITH_PREFIX = 2,
		HIDE = 4
	}
	public static class PlayerSender
	{
		public static void SendPlayerAvatar(SerializedAvatarStats stats, string barcode)
		{
			if (NetworkInfo.HasServer)
			{
				MessageRelay.RelayNative(new PlayerRepAvatarData
				{
					Stats = stats,
					Barcode = barcode
				}, NativeMessageTag.PlayerRepAvatar, CommonMessageRoutes.ReliableToOtherClients);
			}
		}

		public static void SendPlayerVoiceChat(byte[] voiceData)
		{
			if (NetworkInfo.HasServer)
			{
				MessageRelay.RelayNative(new PlayerVoiceChatData
				{
					Bytes = voiceData
				}, NativeMessageTag.PlayerVoiceChat, CommonMessageRoutes.UnreliableToOtherClients);
			}
		}

		public static void SendPlayerTeleport(byte target, Vector3 position)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkInfo.IsHost)
			{
				MessageRelay.RelayNative(new PlayerRepTeleportData
				{
					Position = position
				}, NativeMessageTag.PlayerRepTeleport, new MessageRoute(target, NetworkChannel.Reliable));
			}
		}

		public static void SendPlayerDamage(byte target, Attack attack)
		{
			SendPlayerDamage(target, attack, (BodyPart)2);
		}

		public static void SendPlayerDamage(byte target, Attack attack, BodyPart part)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			MessageRelay.RelayNative(new PlayerRepDamageData
			{
				Attack = new SerializedAttack(attack),
				Part = part
			}, NativeMessageTag.PlayerRepDamage, new MessageRoute(target, NetworkChannel.Reliable));
		}

		public static void SendPlayerMetadataRequest(byte smallID, string key, string value)
		{
			MessageRelay.RelayNative(new PlayerMetadataData
			{
				Player = new PlayerReference(smallID),
				Key = key,
				Value = value
			}, NativeMessageTag.PlayerMetadataRequest, CommonMessageRoutes.ReliableToServer);
		}

		public static void SendPlayerMetadataResponse(byte smallID, string key, string value)
		{
			if (!NetworkInfo.IsHost)
			{
				throw new MessageExpectedServerException();
			}
			MessageRelay.RelayNative(new PlayerMetadataData
			{
				Player = new PlayerReference(smallID),
				Key = key,
				Value = value
			}, NativeMessageTag.PlayerMetadataResponse, CommonMessageRoutes.ReliableToClients);
		}

		public static void SendPlayerAction(PlayerActionType type, byte? otherPlayer = null)
		{
			MessageRelay.RelayNative(new PlayerRepActionData
			{
				Type = type,
				OtherPlayer = otherPlayer
			}, NativeMessageTag.PlayerRepAction, CommonMessageRoutes.ReliableToClients);
		}
	}
	public static class PropSender
	{
		private struct PropCreationInfo
		{
			public MarrowEntity marrowEntity;

			public Action<NetworkEntity> onFinished;

			public bool waitUntilEnabled;
		}

		public static void SendCatchupCreation(NetworkProp prop, PlayerID playerId)
		{
			if (NetworkInfo.IsHost)
			{
				ComponentHashData dataFromEntity = MarrowEntityHelper.GetDataFromEntity(prop.MarrowEntity);
				if (dataFromEntity != null)
				{
					NetworkEntity networkEntity = prop.NetworkEntity;
					MessageRelay.RelayNative(NetworkPropCreateData.Create(networkEntity.OwnerID, dataFromEntity, networkEntity.ID), NativeMessageTag.NetworkPropCreate, new MessageRoute(playerId.SmallID, NetworkChannel.Reliable));
				}
			}
		}

		public static void SendPropCreation(MarrowEntity marrowEntity, Action<NetworkEntity> onFinished = null, bool waitUntilEnabled = false)
		{
			if (IMarrowEntityExtender.Cache.TryGet(marrowEntity, out var value))
			{
				onFinished?.Invoke(value);
				return;
			}
			PropCreationInfo info = new PropCreationInfo
			{
				marrowEntity = marrowEntity,
				onFinished = onFinished,
				waitUntilEnabled = waitUntilEnabled
			};
			FusionSceneManager.HookOnDelayedLevelLoad(delegate
			{
				Internal_InitializePropSyncable(info);
			});
		}

		private static void Internal_InitializePropSyncable(PropCreationInfo info)
		{
			NetworkEntity newEntity = null;
			NetworkProp newProp = null;
			if (info.waitUntilEnabled)
			{
				((Component)info.marrowEntity).gameObject.AddComponent<NotifyOnEnable>().Hook(OnStart);
			}
			else
			{
				OnStart();
			}
			void OnFinish()
			{
				newEntity.SetOwner(PlayerIDManager.LocalID);
				info.onFinished?.Invoke(newEntity);
			}
			void OnRegistered(NetworkEntity networkEntity, MarrowEntity marrowEntity)
			{
				if (!networkEntity.IsDestroyed)
				{
					ComponentHashData dataFromEntity = MarrowEntityHelper.GetDataFromEntity(marrowEntity);
					if (dataFromEntity != null)
					{
						MessageRelay.RelayNative(NetworkPropCreateData.Create(PlayerIDManager.LocalSmallID, dataFromEntity, newEntity.ID), NativeMessageTag.NetworkPropCreate, CommonMessageRoutes.ReliableToOtherClients);
						OnFinish();
					}
				}
			}
			void OnStart()
			{
				if (!IMarrowEntityExtender.Cache.ContainsSource(info.marrowEntity) && MarrowEntityHelper.IsHashed(info.marrowEntity))
				{
					newEntity = new NetworkEntity
					{
						Source = EntitySource.Scene
					};
					newProp = new NetworkProp(newEntity, info.marrowEntity);
					NetworkEntityManager.RequestUnqueue(NetworkEntityManager.IDManager.QueueEntity(newEntity));
					newEntity.HookOnRegistered(delegate
					{
						OnRegistered(newEntity, info.marrowEntity);
					});
				}
			}
		}
	}
	public static class SpawnSender
	{
		public static void SendCatchupSpawn(byte ownerID, string barcode, ushort entityID, SerializedTransform serializedTransform, byte playerID, EntitySource source)
		{
			if (NetworkInfo.IsHost)
			{
				MessageRelay.RelayNative(new SpawnResponseData
				{
					OwnerID = ownerID,
					EntityID = entityID,
					SpawnData = new SerializedSpawnData
					{
						Barcode = barcode,
						SerializedTransform = serializedTransform,
						SpawnEffect = false,
						SpawnSource = source
					}
				}, NativeMessageTag.SpawnResponse, new MessageRoute(playerID, NetworkChannel.Reliable));
			}
		}
	}
	public static class ConnectionSender
	{
		public static void SendDisconnectToAll(string reason = "")
		{
			if (!NetworkInfo.IsHost)
			{
				return;
			}
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				if (playerID.IsMe)
				{
					continue;
				}
				using NetWriter netWriter = NetWriter.Create();
				DisconnectMessageData value = DisconnectMessageData.Create(playerID.PlatformID, reason);
				NetSerializerExtensions.SerializeValue(netWriter, ref value);
				using NetMessage message = NetMessage.Create(NativeMessageTag.Disconnect, netWriter, CommonMessageRoutes.None);
				MessageSender.SendFromServer(playerID.PlatformID, NetworkChannel.Reliable, message);
				NetworkConnectionManager.TimeoutDisconnect(playerID.PlatformID);
			}
		}

		public static void SendDisconnect(ulong platformID, string reason = "")
		{
			if (!NetworkInfo.IsHost)
			{
				return;
			}
			using NetWriter netWriter = NetWriter.Create();
			DisconnectMessageData value = DisconnectMessageData.Create(platformID, reason);
			NetSerializerExtensions.SerializeValue(netWriter, ref value);
			using NetMessage message = NetMessage.Create(NativeMessageTag.Disconnect, netWriter, CommonMessageRoutes.None);
			MessageSender.BroadcastMessage(NetworkChannel.Reliable, message);
			NetworkConnectionManager.TimeoutDisconnect(platformID);
		}

		public static void SendConnectionDeny(ulong platformID, string reason = "")
		{
			if (!NetworkInfo.IsHost)
			{
				return;
			}
			using NetWriter netWriter = NetWriter.Create();
			DisconnectMessageData value = DisconnectMessageData.Create(platformID, reason);
			NetSerializerExtensions.SerializeValue(netWriter, ref value);
			using NetMessage message = NetMessage.Create(NativeMessageTag.Disconnect, netWriter, CommonMessageRoutes.None);
			MessageSender.SendFromServer(platformID, NetworkChannel.Reliable, message);
			NetworkConnectionManager.TimeoutDisconnect(platformID);
		}

		public static void SendConnectionRequest()
		{
			if (NetworkInfo.HasServer)
			{
				using (NetWriter netWriter = NetWriter.Create())
				{
					ConnectionRequestData.Create(PlayerIDManager.LocalPlatformID, FusionMod.Version, RigData.GetAvatarBarcode(), RigData.RigAvatarStats).Serialize(netWriter);
					using NetMessage message = NetMessage.Create(NativeMessageTag.ConnectionRequest, netWriter, CommonMessageRoutes.None);
					MessageSender.BroadcastMessage(NetworkChannel.Reliable, message);
					return;
				}
			}
			FusionLogger.Error("Attempted to send a connection request, but we are not connected to anyone!");
		}

		public static void SendPlayerCatchup(ulong newUser, PlayerID id, string avatar, SerializedAvatarStats stats)
		{
			using NetWriter netWriter = NetWriter.Create();
			ConnectionResponseData value = ConnectionResponseData.Create(id, avatar, stats, isInitialJoin: false);
			NetSerializerExtensions.SerializeValue(netWriter, ref value);
			using NetMessage message = NetMessage.Create(NativeMessageTag.ConnectionResponse, netWriter, CommonMessageRoutes.None);
			MessageSender.SendFromServer(newUser, NetworkChannel.Reliable, message);
		}

		public static void SendPlayerJoin(PlayerID id, string avatar, SerializedAvatarStats stats)
		{
			using NetWriter netWriter = NetWriter.Create();
			ConnectionResponseData value = ConnectionResponseData.Create(id, avatar, stats, isInitialJoin: true);
			NetSerializerExtensions.SerializeValue(netWriter, ref value);
			using NetMessage message = NetMessage.Create(NativeMessageTag.ConnectionResponse, netWriter, CommonMessageRoutes.None);
			MessageSender.BroadcastMessage(NetworkChannel.Reliable, message);
		}
	}
	public static class LoadSender
	{
		public static void SendLevelRequest(LevelCrate crate)
		{
			if (!NetworkInfo.IsHost)
			{
				MessageRelay.RelayNative(new LevelRequestData
				{
					Barcode = ((Scannable)crate).Barcode.ID,
					Title = ((Scannable)crate).Title
				}, NativeMessageTag.LevelRequest, CommonMessageRoutes.ReliableToServer);
			}
		}

		public static void SendLevelLoad(string barcode, string loadBarcode, ulong userId)
		{
			if (!NetworkInfo.IsHost)
			{
				return;
			}
			using NetWriter netWriter = NetWriter.Create();
			LevelLoadData value = new LevelLoadData
			{
				LevelBarcode = barcode,
				LoadingScreenBarcode = loadBarcode
			};
			NetSerializerExtensions.SerializeValue(netWriter, ref value);
			using NetMessage message = NetMessage.Create(NativeMessageTag.SceneLoad, netWriter, CommonMessageRoutes.None);
			MessageSender.SendFromServer(userId, NetworkChannel.Reliable, message);
		}

		public static void SendLoadingState(bool isLoading)
		{
			LocalPlayer.Metadata.Loading.SetValue(isLoading);
		}

		public static void SendLevelLoad(string barcode, string loadBarcode)
		{
			if (NetworkInfo.IsHost)
			{
				MessageRelay.RelayNative(new LevelLoadData
				{
					LevelBarcode = barcode,
					LoadingScreenBarcode = loadBarcode
				}, NativeMessageTag.SceneLoad, CommonMessageRoutes.ReliableToOtherClients);
			}
		}
	}
	public static class PermissionSender
	{
		public static void SendPermissionRequest(PermissionCommandType type, byte? otherPlayer = null)
		{
			MessageRelay.RelayNative(new PermissionCommandRequestData
			{
				Type = type,
				OtherPlayer = otherPlayer
			}, NativeMessageTag.PermissionCommandRequest, CommonMessageRoutes.ReliableToServer);
		}
	}
	public enum TimeScaleMode
	{
		DISABLED,
		LOW_GRAVITY,
		HOST_ONLY,
		EVERYONE,
		CLIENT_SIDE
	}
	public static class TimeScaleSender
	{
		public static void SendSlowMoButton(bool decrease)
		{
			MessageRelay.RelayNative(new SlowMoButtonMessageData
			{
				Decrease = decrease
			}, NativeMessageTag.SlowMoButton, CommonMessageRoutes.ReliableToOtherClients);
		}
	}
}
namespace LabFusion.SDK
{
	public sealed class SDKModule : LabFusion.SDK.Modules.Module
	{
		public override string Name => "Fusion SDK";

		public override string Author => "Lakatrazz";

		public override Version Version => FusionMod.Version;

		public override ConsoleColor Color => ConsoleColor.White;

		protected override void OnModuleRegistered()
		{
			ModuleMessageManager.RegisterHandler<AnimationStateMessage>();
			ModuleMessageManager.RegisterHandler<GamemodeDropperMessage>();
			ModuleMessageManager.RegisterHandler<VoiceProxyInputMessage>();
		}
	}
}
namespace LabFusion.SDK.Triggers
{
	public class TriggerEvent
	{
		public TriggerRelay Relay { get; }

		public string Name { get; }

		public bool ServerOnly { get; }

		public event Action OnTriggered;

		public event Action<string> OnTriggeredWithValue;

		public TriggerEvent(string name, TriggerRelay relay, bool serverOnly = false)
		{
			Name = name;
			Relay = relay;
			ServerOnly = serverOnly;
			relay.OnTriggered += OnRelayTriggered;
			relay.OnTriggeredWithValue += OnRelayTriggeredWithValue;
		}

		public void UnregisterEvent()
		{
			Relay.OnTriggered -= OnRelayTriggered;
			Relay.OnTriggeredWithValue -= OnRelayTriggeredWithValue;
			this.OnTriggered = null;
			this.OnTriggeredWithValue = null;
		}

		private void OnRelayTriggered(string name)
		{
			if (!(Name != name))
			{
				this.OnTriggered?.Invoke();
			}
		}

		private void OnRelayTriggeredWithValue(string name, string value)
		{
			if (!(Name != name))
			{
				this.OnTriggeredWithValue?.Invoke(value);
			}
		}

		public bool TryInvoke()
		{
			if (!CanInvoke())
			{
				return false;
			}
			return Relay.TryInvokeTrigger(Name);
		}

		public bool TryInvoke(string value)
		{
			if (!CanInvoke())
			{
				return false;
			}
			return Relay.TryInvokeTrigger(Name, value);
		}

		public bool CanInvoke()
		{
			if (ServerOnly && !NetworkInfo.IsHost)
			{
				return false;
			}
			return true;
		}
	}
	public class TriggerRelay
	{
		public delegate bool TriggerDelegate(string name);

		public delegate bool TriggerValueDelegate(string name, string value);

		public TriggerDelegate OnTryInvokeTrigger;

		public TriggerValueDelegate OnTryInvokeTriggerWithValue;

		public event Action<string> OnTriggered;

		public event Action<string, string> OnTriggeredWithValue;

		public bool TryInvokeTrigger(string name)
		{
			if (OnTryInvokeTrigger == null)
			{
				return false;
			}
			return OnTryInvokeTrigger(name);
		}

		public bool TryInvokeTrigger(string name, string value)
		{
			if (OnTryInvokeTriggerWithValue == null)
			{
				return false;
			}
			return OnTryInvokeTriggerWithValue(name, value);
		}

		public void ForceInvokeLocalTrigger(string name)
		{
			this.OnTriggered?.Invoke(name);
		}

		public void ForceInvokeLocalTrigger(string name, string value)
		{
			this.OnTriggeredWithValue?.Invoke(name, value);
		}
	}
}
namespace LabFusion.SDK.Scene
{
	public abstract class GamemodeLevelEventHandler : LevelEventHandler
	{
		public abstract Vector3[] GamemodeMarkerPoints { get; }

		protected override void OnLevelLoaded()
		{
			GamemodeHelper.CreateMarkers(GamemodeMarkerPoints, null, ((ScannableReference)FusionBoneTagReferences.TeamLavaGangReference).Barcode.ID, ((ScannableReference)FusionBoneTagReferences.TeamSabrelakeReference).Barcode.ID);
		}
	}
}
namespace LabFusion.SDK.Points
{
	public static class BitEconomy
	{
		public const int PricelessValue = 1000000;
	}
	[CompiledPointItem]
	public class BitMiner : PointItem
	{
		private float _bitTime;

		public override string Title => "Bit Miner";

		public override string Author => "Lakatrazz";

		public override string Description => CreateDescription(1);

		public override int Price => 600;

		public override string[] Tags => new string[2] { "Utility", "Passive" };

		public override PointItemUpgrade[] Upgrades => new PointItemUpgrade[4]
		{
			new PointItemUpgrade(Description + CreateNextLevelDescription(1), 1000),
			new PointItemUpgrade(CreateDescription(2) + CreateNextLevelDescription(2), 1200),
			new PointItemUpgrade(CreateDescription(3) + CreateNextLevelDescription(3), 3000),
			new PointItemUpgrade(CreateDescription(4) + CreateNextLevelDescription(4), 4200, CreateDescription(5) + "\n\nLevel: 4")
		};

		public override bool ImplementLateUpdate => true;

		private static string CreateNextLevelDescription(int level)
		{
			return $"\nNext: {level + 1} Bits/Player/Minute";
		}

		private static string CreateDescription(int bits)
		{
			string value = ((bits != 1) ? "s" : "");
			return $"<size=18>Hires NullMen to extract void energy from the depths of MythOS.\n\nCurrent: {bits} Bit{value}/Player/Minute";
		}

		public override void OnLateUpdate()
		{
			if (!IsUnlocked || !base.IsEquipped || !NetworkInfo.HasServer)
			{
				return;
			}
			if (!PlayerIDManager.HasOtherPlayers)
			{
				_bitTime = 0f;
				return;
			}
			_bitTime += TimeReferences.DeltaTime;
			if (_bitTime > 60f)
			{
				while (_bitTime > 60f)
				{
					_bitTime -= 60f;
					PointItemManager.RewardBits(CalculateBitReward(), popup: false);
				}
			}
		}

		private int CalculateBitReward()
		{
			int num = 2 + base.CurrentUpgradeIndex;
			int num2 = PlayerIDManager.PlayerCount - 1;
			return num * num2;
		}

		public override void LoadPreviewIcon(Action<Texture2D> onLoaded)
		{
			onLoaded(((Il2CppObjectBase)MenuResources.GetPointIcon(Title)).TryCast<Texture2D>());
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class CompiledPointItemAttribute : Attribute
	{
	}
	public enum PointItemPayloadType
	{
		SELF,
		MIRROR,
		PLAYER_REP
	}
	public struct PointItemPayload
	{
		public PointItemPayloadType type;

		public RigManager rigManager;

		public Mirror mirror;

		public PlayerID playerId;
	}
	public sealed class PointItemUpgrade
	{
		public string Description { get; }

		public int Price { get; }

		public string PurchasedDescription { get; }

		public PointItemUpgrade(string description, int price, string purchasedDescription = null)
		{
			Description = description;
			Price = price;
			if (purchasedDescription == null)
			{
				PurchasedDescription = description;
			}
			else
			{
				PurchasedDescription = purchasedDescription;
			}
		}
	}
	public abstract class PointItem
	{
		public abstract string Title { get; }

		public abstract string Author { get; }

		public virtual string Category => "Fusion Content";

		public virtual string[] Tags => null;

		public virtual PointItemUpgrade[] Upgrades => null;

		public virtual string Version => "1.0.0";

		public abstract string Description { get; }

		public virtual string Barcode => Author + "." + Title + ".Item";

		public virtual bool Redacted => false;

		public abstract int Price { get; }

		public int CurrentPrice
		{
			get
			{
				if (IsUnlocked)
				{
					if (NextUpgrade != null)
					{
						return NextUpgrade.Price;
					}
					if (CurrentUpgrade != null)
					{
						return CurrentUpgrade.Price;
					}
				}
				return Price;
			}
		}

		public string CurrentDescription
		{
			get
			{
				if (IsUnlocked)
				{
					if (NextUpgrade != null)
					{
						return NextUpgrade.Description;
					}
					if (CurrentUpgrade != null)
					{
						return CurrentUpgrade.PurchasedDescription;
					}
				}
				return Description;
			}
		}

		public virtual bool Equippable => true;

		public virtual bool ImplementUpdate => false;

		public virtual bool ImplementFixedUpdate => false;

		public virtual bool ImplementLateUpdate => false;

		public PointItemUpgrade CurrentUpgrade
		{
			get
			{
				if (Upgrades == null || CurrentUpgradeIndex <= -1)
				{
					return null;
				}
				return Upgrades[CurrentUpgradeIndex];
			}
		}

		public PointItemUpgrade NextUpgrade
		{
			get
			{
				if (IsMaxUpgrade)
				{
					return null;
				}
				return Upgrades[CurrentUpgradeIndex + 1];
			}
		}

		public bool IsMaxUpgrade => CurrentUpgradeIndex >= UpgradeCount - 1;

		public bool HasUpgrades => UpgradeCount > 0;

		public int CurrentUpgradeIndex
		{
			get
			{
				if (Upgrades == null || Upgrades.Length == 0)
				{
					return -1;
				}
				return System.Math.Min(PointSaveManager.GetUpgradeLevel(Barcode), Upgrades.Length - 1);
			}
		}

		public int UpgradeCount
		{
			get
			{
				if (Upgrades == null || Upgrades.Length == 0)
				{
					return -1;
				}
				return Upgrades.Length;
			}
		}

		public virtual bool IsUnlocked => PointSaveManager.IsUnlocked(Barcode);

		public bool IsEquipped => PointSaveManager.IsEquipped(Barcode);

		public string MainTag
		{
			get
			{
				if (Tags != null && Tags.Length != 0)
				{
					return Tags[0];
				}
				return "Misc";
			}
		}

		public RarityLevel Rarity => PointItemManager.CalculateLevel(CurrentPrice);

		public abstract void LoadPreviewIcon(Action<Texture2D> onLoaded);

		internal void Register()
		{
			if (ImplementFixedUpdate)
			{
				MultiplayerHooking.OnFixedUpdate += OnFixedUpdate;
			}
			if (ImplementUpdate)
			{
				MultiplayerHooking.OnUpdate += OnUpdate;
			}
			if (ImplementLateUpdate)
			{
				MultiplayerHooking.OnLateUpdate += OnLateUpdate;
			}
			OnRegistered();
		}

		public virtual void OnRegistered()
		{
		}

		internal void Unregister()
		{
			if (ImplementFixedUpdate)
			{
				MultiplayerHooking.OnFixedUpdate -= OnFixedUpdate;
			}
			if (ImplementUpdate)
			{
				MultiplayerHooking.OnUpdate -= OnUpdate;
			}
			if (ImplementLateUpdate)
			{
				MultiplayerHooking.OnLateUpdate -= OnLateUpdate;
			}
			OnUnregistered();
		}

		public virtual void OnUnregistered()
		{
		}

		public virtual void OnFixedUpdate()
		{
		}

		public virtual void OnUpdate()
		{
		}

		public virtual void OnLateUpdate()
		{
		}

		public virtual void OnEquipChanged(PointItemPayload payload, bool isEquipped)
		{
		}

		public virtual void OnUpdateObjects(PointItemPayload payload, bool isVisible)
		{
		}

		public void Trigger()
		{
			PointItemManager.Internal_OnTriggerItem(PlayerIDManager.LocalID, Barcode);
			PointItemSender.SendPointItemTrigger(Barcode);
		}

		public void Trigger(string value)
		{
			PointItemManager.Internal_OnTriggerItem(PlayerIDManager.LocalID, Barcode, value);
			PointItemSender.SendPointItemTrigger(Barcode, value);
		}

		public virtual void OnTrigger(PointItemPayload payload)
		{
		}

		public virtual void OnTrigger(PointItemPayload payload, string value)
		{
		}
	}
	public enum RarityLevel
	{
		Gray = -1,
		White,
		Blue,
		Green,
		Orange,
		LightRed,
		Pink,
		LightPurple,
		Lime,
		Yellow,
		Cyan,
		Red,
		Purple
	}
	public enum SortMode
	{
		PRICE,
		NAME,
		TAG,
		EQUIPPED,
		UNEQUIPPED,
		LAST_SORT
	}
	public static class PointItemManager
	{
		internal static readonly List<PointItem> PointItems;

		internal static readonly Dictionary<string, PointItem> PointItemLookup;

		public static IReadOnlyList<PointItem> LoadedItems => PointItems;

		public static event Action OnBitCountChanged;

		public static event Action<PointItem> OnItemUnlocked;

		public static RarityLevel CalculateLevel(int price)
		{
			if (price >= 5000)
			{
				return RarityLevel.Purple;
			}
			if (price >= 4000)
			{
				return RarityLevel.Red;
			}
			if (price >= 3000)
			{
				return RarityLevel.Cyan;
			}
			if (price >= 2500)
			{
				return RarityLevel.Yellow;
			}
			if (price >= 2000)
			{
				return RarityLevel.Lime;
			}
			if (price >= 1500)
			{
				return RarityLevel.LightPurple;
			}
			if (price >= 1200)
			{
				return RarityLevel.Pink;
			}
			if (price >= 1000)
			{
				return RarityLevel.LightRed;
			}
			if (price >= 800)
			{
				return RarityLevel.Orange;
			}
			if (price >= 300)
			{
				return RarityLevel.Green;
			}
			if (price >= 200)
			{
				return RarityLevel.Blue;
			}
			if (price >= 120)
			{
				return RarityLevel.White;
			}
			return RarityLevel.Gray;
		}

		public static Color ParseColor(RarityLevel level)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(level switch
			{
				RarityLevel.Gray => Color.gray, 
				RarityLevel.Blue => Color.blue, 
				RarityLevel.Green => Color.green, 
				RarityLevel.Orange => new Color(1f, 0.647f, 0f), 
				RarityLevel.LightRed => new Color(1f, 0.447f, 0.462f), 
				RarityLevel.Pink => new Color(1f, 0.411f, 0.7f), 
				RarityLevel.LightPurple => new Color(0.796f, 0.764f, 0.89f), 
				RarityLevel.Lime => new Color(0.749f, 1f, 0f), 
				RarityLevel.Yellow => Color.yellow, 
				RarityLevel.Cyan => Color.cyan, 
				RarityLevel.Red => Color.red, 
				RarityLevel.Purple => new Color(0.5f, 0f, 0.5f), 
				_ => Color.white, 
			});
		}

		public static string ParsePrice(int price, bool unlocked = false)
		{
			if (unlocked)
			{
				return "Bought";
			}
			if (price <= 0)
			{
				return "Free";
			}
			if (price > 1000000)
			{
				return "Priceless";
			}
			return $"{price} Bits";
		}

		internal static void HookEvents()
		{
			LocalPlayer.OnLocalRigCreated = (Action<RigManager>)Delegate.Combine(LocalPlayer.OnLocalRigCreated, new Action<RigManager>(OnLocalRigCreated));
			NetworkPlayer.OnNetworkRigCreated += OnNetworkRigCreated;
		}

		internal static void UnhookEvents()
		{
			LocalPlayer.OnLocalRigCreated = (Action<RigManager>)Delegate.Remove(LocalPlayer.OnLocalRigCreated, new Action<RigManager>(OnLocalRigCreated));
			NetworkPlayer.OnNetworkRigCreated -= OnNetworkRigCreated;
		}

		private static void OnLocalRigCreated(RigManager rigManager)
		{
			foreach (PointItem loadedItem in LoadedItems)
			{
				if (loadedItem.IsEquipped)
				{
					loadedItem.OnUpdateObjects(new PointItemPayload
					{
						type = PointItemPayloadType.SELF,
						rigManager = rigManager,
						playerId = PlayerIDManager.LocalID
					}, isVisible: true);
				}
			}
		}

		private static void OnNetworkRigCreated(NetworkPlayer player, RigManager rigManager)
		{
			if (player.NetworkEntity.IsOwner)
			{
				return;
			}
			foreach (PointItem loadedItem in LoadedItems)
			{
				if (player.PlayerID.EquippedItems.Contains(loadedItem.Barcode))
				{
					loadedItem.OnUpdateObjects(new PointItemPayload
					{
						type = PointItemPayloadType.PLAYER_REP,
						rigManager = rigManager,
						playerId = player.PlayerID
					}, isVisible: true);
				}
			}
		}

		public static void LoadItems(Assembly assembly)
		{
			if (assembly == null)
			{
				throw new NullReferenceException("Tried loading point items from a null assembly!");
			}
			AssemblyUtilities.LoadAllValid<PointItem>(assembly, RegisterPointItem);
		}

		public static void RegisterPointItem<T>() where T : PointItem
		{
			RegisterPointItem(typeof(T));
		}

		private static void RegisterPointItem(Type type)
		{
			if (type.GetCustomAttribute<CompiledPointItemAttribute>() != null)
			{
				RegisterPointItem(Activator.CreateInstance(type) as PointItem);
			}
		}

		public static void RegisterPointItem(PointItem item)
		{
			if (PointItemLookup.ContainsKey(item.Barcode))
			{
				FusionLogger.Error("Tried registering PointItem with barcode " + item.Barcode + ", but that barcode was already registered!");
				return;
			}
			PointItems.Add(item);
			PointItemLookup.Add(item.Barcode, item);
			item.Register();
			if (item.IsEquipped)
			{
				OnEquipChanged(PlayerIDManager.LocalID, item.Barcode, isEquipped: true);
			}
		}

		public static bool TryGetPointItem(string barcode, out PointItem item)
		{
			if (string.IsNullOrWhiteSpace(barcode))
			{
				item = null;
				return false;
			}
			return PointItemLookup.TryGetValue(barcode, out item);
		}

		public static int GetBitCount()
		{
			return PointSaveManager.GetBitCount();
		}

		public static void RewardBits(int bits, bool popup = true)
		{
			bits = System.Math.Max(0, bits);
			if (bits.IsNaN())
			{
				FusionLogger.ErrorLine("Prevented attempt to give invalid bit reward. Please notify a Fusion developer and send them your log.", 262);
				return;
			}
			PointSaveManager.SetBitCount(GetBitCount() + bits);
			if (popup)
			{
				BitPopup.Send(bits);
			}
			PointItemManager.OnBitCountChanged.InvokeSafe("executing OnBitCountChanged");
		}

		public static void DecrementBits(int bits, bool popup = true)
		{
			bits = System.Math.Max(0, bits);
			if (bits.IsNaN())
			{
				FusionLogger.ErrorLine("Prevented attempt to remove an invalid bit amount. Please notify a Fusion developer and send them your log.", 284);
				return;
			}
			PointSaveManager.SetBitCount(GetBitCount() - bits);
			if (popup)
			{
				BitPopup.Send(-bits);
			}
			PointItemManager.OnBitCountChanged.InvokeSafe("executing OnBitCountChanged");
		}

		public static bool TryUpgradeItem(PointItem item)
		{
			if (!GetUnlockedItems().Contains(item))
			{
				return false;
			}
			if (item.IsMaxUpgrade)
			{
				return false;
			}
			int currentPrice = item.CurrentPrice;
			int bitCount = GetBitCount();
			if (currentPrice < 0)
			{
				return false;
			}
			if (currentPrice > bitCount)
			{
				return false;
			}
			PointSaveManager.UpgradeItem(item.Barcode);
			DecrementBits(currentPrice);
			return true;
		}

		public static bool TryBuyItem(PointItem item)
		{
			if (GetUnlockedItems().Contains(item))
			{
				return false;
			}
			int price = item.Price;
			int bitCount = GetBitCount();
			if (price < 0)
			{
				return false;
			}
			if (price > bitCount)
			{
				return false;
			}
			PointSaveManager.UnlockItem(item.Barcode);
			DecrementBits(price);
			PointItemManager.OnItemUnlocked?.Invoke(item);
			return true;
		}

		internal static void OnEquipChanged(PlayerID id, string barcode, bool isEquipped)
		{
			if (!TryGetPointItem(barcode, out var item))
			{
				return;
			}
			RigManager val = null;
			PointItemPayloadType type = PointItemPayloadType.SELF;
			NetworkPlayer player;
			if (id == null || id.IsMe)
			{
				if (!RigData.HasPlayer)
				{
					return;
				}
				val = RigData.Refs.RigManager;
				type = PointItemPayloadType.SELF;
			}
			else if (NetworkPlayerManager.TryGetPlayer((byte)id, out player))
			{
				if (!player.HasRig)
				{
					return;
				}
				val = player.RigRefs.RigManager;
				type = PointItemPayloadType.PLAYER_REP;
			}
			PointItemPayload pointItemPayload = default(PointItemPayload);
			pointItemPayload.type = type;
			pointItemPayload.playerId = id;
			pointItemPayload.rigManager = val;
			PointItemPayload payload = pointItemPayload;
			item.OnEquipChanged(payload, isEquipped);
			if ((Object)(object)val != (Object)null)
			{
				item.OnUpdateObjects(payload, isEquipped);
			}
		}

		internal static void Internal_OnTriggerItem(PlayerID id, string barcode, string value = null)
		{
			if (TryGetPointItem(barcode, out var item))
			{
				RigManager rigManager = null;
				PointItemPayloadType type = PointItemPayloadType.SELF;
				NetworkPlayer player;
				if (id == null || id.IsMe)
				{
					rigManager = RigData.Refs.RigManager;
					type = PointItemPayloadType.SELF;
				}
				else if (NetworkPlayerManager.TryGetPlayer((byte)id, out player))
				{
					rigManager = player.RigRefs.RigManager;
					type = PointItemPayloadType.PLAYER_REP;
				}
				PointItemPayload pointItemPayload = default(PointItemPayload);
				pointItemPayload.type = type;
				pointItemPayload.playerId = id;
				pointItemPayload.rigManager = rigManager;
				PointItemPayload payload = pointItemPayload;
				if (value != null)
				{
					item.OnTrigger(payload, value);
				}
				else
				{
					item.OnTrigger(payload);
				}
			}
		}

		public static void SetEquipped(PointItem item, bool isEquipped)
		{
			if (item != null && (item.IsUnlocked || item.IsEquipped))
			{
				OnEquipChanged(PlayerIDManager.LocalID, item.Barcode, isEquipped);
				PointSaveManager.SetEquipped(item.Barcode, isEquipped);
				PointItemSender.SendPointItemEquip(item.Barcode, isEquipped);
			}
		}

		public static void UnequipAll()
		{
			foreach (PointItem loadedItem in LoadedItems)
			{
				SetEquipped(loadedItem, isEquipped: false);
			}
		}

		public static IReadOnlyList<PointItem> GetLockedItems(SortMode sort = SortMode.PRICE)
		{
			List<PointItem> items = new List<PointItem>(LoadedItems.Count);
			foreach (PointItem loadedItem in LoadedItems)
			{
				if (!loadedItem.Redacted && (sort != SortMode.EQUIPPED || loadedItem.IsEquipped) && (sort != SortMode.UNEQUIPPED || !loadedItem.IsEquipped) && !loadedItem.IsUnlocked)
				{
					items.Add(loadedItem);
				}
			}
			SortBy(ref items, sort);
			return items;
		}

		public static IReadOnlyList<PointItem> GetUnlockedItems(SortMode sort = SortMode.PRICE)
		{
			List<PointItem> items = new List<PointItem>(LoadedItems.Count);
			foreach (PointItem loadedItem in LoadedItems)
			{
				if ((sort != SortMode.EQUIPPED || loadedItem.IsEquipped) && (sort != SortMode.UNEQUIPPED || !loadedItem.IsEquipped) && loadedItem.IsUnlocked)
				{
					items.Add(loadedItem);
				}
			}
			SortBy(ref items, sort);
			return items;
		}

		private static void SortBy(ref List<PointItem> items, SortMode sort)
		{
			switch (sort)
			{
			case SortMode.PRICE:
				items.Sort((PointItem x, PointItem y) => x.Price - y.Price);
				break;
			case SortMode.TAG:
				items.Sort((PointItem x, PointItem y) => x.MainTag.CompareTo(y.MainTag));
				break;
			case SortMode.NAME:
				items.Sort((PointItem x, PointItem y) => x.Title.CompareTo(y.Title));
				break;
			}
		}

		static PointItemManager()
		{
			PointItemManager.OnBitCountChanged = null;
			PointItemManager.OnItemUnlocked = null;
			PointItems = new List<PointItem>();
			PointItemLookup = new Dictionary<string, PointItem>();
		}
	}
	public static class PointSaveManager
	{
		[Serializable]
		public class PointSaveData
		{
			[JsonPropertyName("boughtItems")]
			public string[] BoughtItems { get; set; }

			[JsonPropertyName("enabledItems")]
			public string[] EnabledItems { get; set; }

			[JsonPropertyName("upgradedItems")]
			public Dictionary<string, int> UpgradedItems { get; set; }

			[JsonPropertyName("bitCount")]
			public int BitCount { get; set; }

			public static PointSaveData CreateCurrent()
			{
				return new PointSaveData
				{
					BoughtItems = _unlockedItems.ToArray(),
					EnabledItems = _equippedItems.ToArray(),
					UpgradedItems = _itemUpgrades,
					BitCount = _totalBits
				};
			}
		}

		private const string _filePath = "point_shop.dat";

		private const string _backupPath = "point_shop.dat.bak";

		private static List<string> _unlockedItems = new List<string>();

		private static List<string> _equippedItems = new List<string>();

		private static Dictionary<string, int> _itemUpgrades = new Dictionary<string, int>();

		private static int _totalBits;

		public static void WriteToFile()
		{
			DataSaver.WriteJsonToFile("point_shop.dat", PointSaveData.CreateCurrent());
		}

		public static void WriteBackup()
		{
			string path = PersistentData.GetPath("point_shop.dat");
			string path2 = PersistentData.GetPath("point_shop.dat.bak");
			if (File.Exists(path))
			{
				File.Copy(path, path2, overwrite: true);
			}
		}

		public static void ReadFile()
		{
			PointSaveData pointSaveData = DataSaver.ReadJsonFromFile<PointSaveData>("point_shop.dat");
			if (pointSaveData != null)
			{
				if (pointSaveData.BoughtItems != null)
				{
					_unlockedItems = pointSaveData.BoughtItems.ToList();
				}
				if (pointSaveData.EnabledItems != null)
				{
					_equippedItems = pointSaveData.EnabledItems.ToList();
				}
				if (pointSaveData.UpgradedItems != null)
				{
					_itemUpgrades = pointSaveData.UpgradedItems;
				}
				_totalBits = pointSaveData.BitCount;
			}
		}

		public static int GetUpgradeLevel(string barcode)
		{
			if (_itemUpgrades.TryGetValue(barcode, out var value))
			{
				return value;
			}
			return -1;
		}

		public static bool IsUnlocked(string barcode)
		{
			return _unlockedItems.Contains(barcode);
		}

		public static bool IsEquipped(string barcode)
		{
			return _equippedItems.Contains(barcode);
		}

		public static void UnlockItem(string barcode)
		{
			if (!_unlockedItems.Contains(barcode))
			{
				_unlockedItems.Add(barcode);
			}
			WriteToFile();
		}

		public static void LockItem(string barcode)
		{
			_unlockedItems.Remove(barcode);
			WriteToFile();
		}

		public static void UpgradeItem(string barcode)
		{
			if (!_itemUpgrades.ContainsKey(barcode))
			{
				_itemUpgrades.Add(barcode, -1);
			}
			_itemUpgrades[barcode]++;
		}

		public static void SetUpgradeLevel(string barcode, int level)
		{
			if (!_itemUpgrades.ContainsKey(barcode))
			{
				_itemUpgrades.Add(barcode, -1);
			}
			_itemUpgrades[barcode] = level;
		}

		public static void SetEquipped(string barcode, bool isEquipped)
		{
			if (isEquipped)
			{
				if (!_equippedItems.Contains(barcode))
				{
					_equippedItems.Add(barcode);
				}
			}
			else
			{
				_equippedItems.Remove(barcode);
			}
			WriteToFile();
		}

		public static int GetBitCount()
		{
			return _totalBits;
		}

		public static void SetBitCount(int count)
		{
			_totalBits = System.Math.Max(0, count);
			WriteToFile();
		}
	}
	public static class PointShopHelper
	{
		public static void SpawnBitMart(Vector3 position, Quaternion rotation)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.BitMartReference);
			LocalAssetSpawner.Register(spawnable);
			LocalAssetSpawner.Spawn(spawnable, position, rotation);
		}
	}
}
namespace LabFusion.SDK.MonoBehaviours
{
	[RegisterTypeInIl2Cpp]
	public class GamemodeItem : MonoBehaviour
	{
		public const float MaxUnheldTime = 20f;

		public const float MaxHeldTime = 60f;

		public const int MaxMeleeHits = 10;

		public const int MaxDamagelessHits = 30;

		private NetworkEntity _entity;

		private NetworkProp _prop;

		private Poolee _poolee;

		private InteractableHost _host;

		private InteractableHostManager _hostManager;

		private MarrowEntity _marrowEntity;

		private GunExtender _gunExtender;

		private StabSlash _stabSlash;

		private BladeAudio _bladeAudio;

		private ImpactSFX _impactSFX;

		private Action<Collision, float> _onSignificantCollisionDelegate;

		private bool _isDespawned;

		private Action<InteractableHost, Hand> _onHandAttachedDelegate;

		private float _despawnTimer;

		private float _heldDespawnTimer;

		private bool _attemptedDespawn;

		private float _lastImpactTime;

		private int _bladeHits;

		private float _bladeHitCooldown;

		private int _impactSFXHits;

		private float _lastImpactSFXTime;

		public bool IsHeld
		{
			get
			{
				if (Object.op_Implicit((Object)(object)_hostManager))
				{
					return _hostManager.grabbedHosts.Count > 0;
				}
				if (Object.op_Implicit((Object)(object)_host))
				{
					return _host.HandCount() > 0;
				}
				return false;
			}
		}

		public bool HasBeenInteracted { get; private set; }

		public GamemodeItem(IntPtr intPtr)
			: base(intPtr)
		{
		}

		[HideFromIl2Cpp]
		public void Initialize(NetworkEntity entity, Poolee poolee)
		{
			_entity = entity;
			_poolee = poolee;
			_prop = entity.GetExtender<NetworkProp>();
			if (_prop != null)
			{
				_marrowEntity = _prop.MarrowEntity;
				HookHost();
				CheckComponents(_marrowEntity);
			}
			CheckExtenders(entity);
			GamemodeDropper.DroppedItems.Add(poolee);
		}

		[HideFromIl2Cpp]
		private void CheckExtenders(NetworkEntity entity)
		{
			GunExtender extender = entity.GetExtender<GunExtender>();
			if (extender != null)
			{
				HookGun(extender);
			}
		}

		private void CheckComponents(MarrowEntity marrowEntity)
		{
			_stabSlash = ((Component)marrowEntity).GetComponent<StabSlash>();
			if ((Object)(object)_stabSlash != (Object)null)
			{
				_bladeAudio = _stabSlash.bladeAudio;
			}
			_impactSFX = ((Component)marrowEntity).GetComponent<ImpactSFX>();
			if ((Object)(object)_impactSFX != (Object)null)
			{
				_onSignificantCollisionDelegate = Action<Collision, float>.op_Implicit((Action<Collision, float>)OnImpactSFXCollision);
				ImpactSFX impactSFX = _impactSFX;
				impactSFX.OnSignificantCollision += _onSignificantCollisionDelegate;
			}
		}

		[HideFromIl2Cpp]
		private void HookGun(GunExtender gunExtender)
		{
			_gunExtender = gunExtender;
			Gun[] components = gunExtender.Components;
			foreach (Gun gun in components)
			{
				Awaiter awaiter = gun.InstantLoadAsync().GetAwaiter();
				Action action = delegate
				{
					gun.Charge();
					gun.hammerState = (HammerStates)1;
					gun.slideState = (SlideStates)1;
					gun.isMagEjectOnEmpty = true;
				};
				awaiter.OnCompleted(Action.op_Implicit(action));
			}
		}

		private void HookHost()
		{
			_host = InteractableHost.Cache.Get(((Component)_marrowEntity).gameObject);
			_hostManager = ((Component)_marrowEntity).gameObject.GetComponent<InteractableHostManager>();
			_onHandAttachedDelegate = Action<InteractableHost, Hand>.op_Implicit((Action<InteractableHost, Hand>)OnHandAttached);
			if ((Object)(object)_hostManager != (Object)null)
			{
				InteractableHostManager hostManager = _hostManager;
				hostManager.onHandAttached += _onHandAttachedDelegate;
			}
			else if ((Object)(object)_host != (Object)null)
			{
				InteractableHost host = _host;
				host.onHandAttachedDelegate += _onHandAttachedDelegate;
			}
		}

		private void UnhookHost()
		{
			if ((Object)(object)_hostManager != (Object)null)
			{
				InteractableHostManager hostManager = _hostManager;
				hostManager.onHandAttached -= _onHandAttachedDelegate;
			}
			else if ((Object)(object)_host != (Object)null)
			{
				InteractableHost host = _host;
				host.onHandAttachedDelegate -= _onHandAttachedDelegate;
			}
			_onHandAttachedDelegate = null;
			_host = null;
			_hostManager = null;
		}

		private void UnhookComponents()
		{
			if ((Object)(object)_impactSFX != (Object)null)
			{
				ImpactSFX impactSFX = _impactSFX;
				impactSFX.OnSignificantCollision -= _onSignificantCollisionDelegate;
				_onSignificantCollisionDelegate = null;
				_impactSFX = null;
			}
		}

		private void OnHandAttached(InteractableHost host, Hand hand)
		{
			HasBeenInteracted = true;
			if (hand.manager.IsLocalPlayer())
			{
				OnGunGrabbed();
			}
		}

		private void OnGunGrabbed()
		{
			if (_gunExtender == null)
			{
				return;
			}
			Gun[] components = _gunExtender.Components;
			foreach (Gun val in components)
			{
				if (val._hasMagState)
				{
					LocalInventory.AddAmmo(val.MagazineState._cartridges.Count);
				}
			}
		}

		private void OnDespawn()
		{
			if (!_isDespawned)
			{
				_isDespawned = true;
				HasBeenInteracted = false;
				_attemptedDespawn = false;
				GamemodeDropper.DroppedItems.Remove(_poolee);
				UnhookHost();
				UnhookComponents();
				_entity = null;
				_prop = null;
				_poolee = null;
				Object.Destroy((Object)(object)this);
			}
		}

		private void OnDisable()
		{
			OnDespawn();
		}

		private void OnCollisionEnter(Collision collision)
		{
			if (!HasBeenInteracted && ((Component)collision.collider).gameObject.layer == 8)
			{
				HasBeenInteracted = true;
			}
		}

		private void Update()
		{
			if (NetworkInfo.IsHost)
			{
				CheckTimedDespawn();
				CheckHeldDespawn();
			}
			CheckGunDespawn();
		}

		private void FixedUpdate()
		{
			ApplyLowGravity();
			CheckStabSlashDespawn();
		}

		private void ApplyLowGravity()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (HasBeenInteracted || (Object)(object)_marrowEntity == (Object)null)
			{
				return;
			}
			Vector3 val = -Physics.gravity * 0.9f;
			foreach (MarrowBody item in (Il2CppArrayBase<MarrowBody>)(object)_marrowEntity.Bodies)
			{
				if (!((Object)(object)item == (Object)null) && item.HasRigidbody)
				{
					Rigidbody rigidbody = item._rigidbody;
					if (rigidbody.useGravity)
					{
						rigidbody.AddForce(val, (ForceMode)5);
					}
				}
			}
		}

		private void CheckTimedDespawn()
		{
			if (IsHeld)
			{
				_despawnTimer = 0f;
				return;
			}
			_despawnTimer += Time.deltaTime;
			if (_despawnTimer >= 20f)
			{
				NetworkAssetSpawner.DespawnRequestInfo info = default(NetworkAssetSpawner.DespawnRequestInfo);
				info.EntityID = _entity.ID;
				info.DespawnEffect = HasBeenInteracted;
				NetworkAssetSpawner.Despawn(info);
			}
		}

		private void CheckHeldDespawn()
		{
			if (IsHeld)
			{
				_heldDespawnTimer += Time.deltaTime;
				if (_heldDespawnTimer >= 60f)
				{
					NetworkAssetSpawner.DespawnRequestInfo info = default(NetworkAssetSpawner.DespawnRequestInfo);
					info.EntityID = _entity.ID;
					info.DespawnEffect = true;
					NetworkAssetSpawner.Despawn(info);
				}
			}
		}

		private bool CanCheckItemUse()
		{
			if (HasBeenInteracted && _entity.IsOwner)
			{
				return !_attemptedDespawn;
			}
			return false;
		}

		private void CheckGunDespawn()
		{
			if (!CanCheckItemUse() || _gunExtender == null)
			{
				return;
			}
			bool flag = false;
			Gun[] components = _gunExtender.Components;
			foreach (Gun val in components)
			{
				if (val.HasMagazine() && val.MagazineState.AmmoCount > 0)
				{
					flag = true;
				}
			}
			if (!flag)
			{
				DespawnFromItemUse();
			}
		}

		private void CheckStabSlashDespawn()
		{
			if (_bladeAudio == null)
			{
				return;
			}
			if (!CanCheckItemUse())
			{
				_lastImpactTime = _bladeAudio._nextImpactTime;
				return;
			}
			if (_bladeHitCooldown > 0f)
			{
				_bladeHitCooldown -= Time.deltaTime;
				_lastImpactTime = _bladeAudio._nextImpactTime;
				return;
			}
			bool num = !Mathf.Approximately(_bladeAudio._nextImpactTime, _lastImpactTime);
			bool flag = (Object)(object)_bladeAudio._relCol.collider != (Object)null && (Object)(object)_bladeAudio._relCol.collider.attachedRigidbody != (Object)null;
			if (num && flag)
			{
				_bladeHits++;
				_bladeHitCooldown = 0.1f;
				if (_bladeHits >= 10)
				{
					DespawnFromItemUse();
				}
				_lastImpactTime = _bladeAudio._nextImpactTime;
			}
		}

		private void OnImpactSFXCollision(Collision collision, float velSquared)
		{
			if (!CanCheckItemUse() || Time.timeSinceLevelLoad - _lastImpactSFXTime < 0.1f || velSquared < _impactSFX._minVelSquared)
			{
				return;
			}
			int num = (_impactSFX.bluntAttack ? 10 : 30);
			if ((Object)(object)collision.rigidbody != (Object)null)
			{
				_impactSFXHits++;
				_lastImpactSFXTime = Time.timeSinceLevelLoad;
				if (_impactSFXHits >= num)
				{
					DespawnFromItemUse();
				}
			}
		}

		private void DespawnFromItemUse()
		{
			NetworkAssetSpawner.DespawnRequestInfo info = default(NetworkAssetSpawner.DespawnRequestInfo);
			info.EntityID = _entity.ID;
			info.DespawnEffect = true;
			NetworkAssetSpawner.Despawn(info);
			_attemptedDespawn = true;
		}
	}
}
namespace LabFusion.SDK.Modules
{
	public abstract class Module
	{
		public abstract string Name { get; }

		public virtual string Author { get; } = "Unknown";


		public virtual Version Version { get; } = new Version();


		public virtual ConsoleColor Color { get; } = ConsoleColor.Magenta;


		public ModuleLogger LoggerInstance { get; private set; }

		internal void Register()
		{
			LoggerInstance = new ModuleLogger(Name);
			OnModuleRegistered();
		}

		protected virtual void OnModuleRegistered()
		{
		}

		protected virtual void OnModuleUnregistered()
		{
		}
	}
	public class ModuleLogger
	{
		private readonly string _moduleName;

		public ModuleLogger(string moduleName)
		{
			_moduleName = moduleName;
		}

		private string Parse(string text)
		{
			return "-> [" + _moduleName + "] " + text;
		}

		public void Log(string text, ConsoleColor color = ConsoleColor.White)
		{
			FusionLogger.Log(Parse(text), color);
		}

		public void Warn(string text)
		{
			FusionLogger.Warn(Parse(text));
		}

		public void Error(string text)
		{
			FusionLogger.Error(Parse(text));
		}

		public void LogException(string task, Exception e)
		{
			FusionLogger.LogException(task, e);
		}
	}
	public static class ModuleManager
	{
		private static readonly List<Module> _modules = new List<Module>();

		public static List<Module> Modules => _modules;

		public static void LoadModules(Assembly assembly)
		{
			if (assembly == null)
			{
				throw new ArgumentNullException("assembly");
			}
			AssemblyUtilities.LoadAllValid<Module>(assembly, RegisterModule);
		}

		public static void RegisterModule(Type type)
		{
			Module module = (Module)Activator.CreateInstance(type);
			LogDescription(module);
			_modules.Add(module);
			module.Register();
		}

		public static void RegisterModule<TModule>() where TModule : Module
		{
			RegisterModule(typeof(TModule));
		}

		private static void LogDescription(Module module)
		{
			FusionLogger.Log("--==== Loaded Fusion Module ====--", module.Color);
			FusionLogger.Log($"{module.Name} - v{module.Version}");
			FusionLogger.Log("by " + module.Author);
			FusionLogger.Log("--=============================--", module.Color);
		}
	}
	public abstract class ModuleMessageHandler : MessageHandler
	{
		internal long? _tag;

		public long? Tag => _tag;

		public sealed override void Handle(ReceivedMessage received)
		{
			CheckExpectedConditions(received);
			OnHandleMessage(received);
		}
	}
	public static class ModuleMessageManager
	{
		public static Dictionary<Type, ModuleMessageHandler> TypeToHandlerLookup { get; private set; } = new Dictionary<Type, ModuleMessageHandler>();


		public static Dictionary<long, ModuleMessageHandler> TagToHandlerLookup { get; private set; } = new Dictionary<long, ModuleMessageHandler>();


		public static List<ModuleMessageHandler> Handlers { get; private set; } = new List<ModuleMessageHandler>();


		public static void LoadHandlers(Assembly assembly)
		{
			if (assembly == null)
			{
				throw new ArgumentNullException("assembly");
			}
			AssemblyUtilities.LoadAllValid<ModuleMessageHandler>(assembly, RegisterHandler);
		}

		public static void RegisterHandler<T>() where T : ModuleMessageHandler
		{
			RegisterHandler(typeof(T));
		}

		public static void RegisterHandler(Type type)
		{
			if (TypeToHandlerLookup.ContainsKey(type))
			{
				throw new ArgumentException("Handler " + type.Name + " was already registered.");
			}
			string? name = type.Assembly.GetName().Name;
			long num = BitMath.MakeLong(right: type.FullName.GetDeterministicHashCode(), left: name.GetDeterministicHashCode());
			if (TagToHandlerLookup.TryGetValue(num, out var value))
			{
				throw new ArgumentException($"Handler {type.Name}'s hashed tag of {num} conflicts with handler {value.GetType().Name}!");
			}
			ModuleMessageHandler moduleMessageHandler = CreateHandler(type, num);
			Handlers.Add(moduleMessageHandler);
			TypeToHandlerLookup[type] = moduleMessageHandler;
			TagToHandlerLookup[num] = moduleMessageHandler;
		}

		private static ModuleMessageHandler CreateHandler(Type type, long tag)
		{
			ModuleMessageHandler obj = (ModuleMessageHandler)Activator.CreateInstance(type);
			obj._tag = tag;
			obj.NetAttributes = type.GetCustomAttributes<Net.NetAttribute>().ToArray();
			return obj;
		}

		public static long? GetHandlerTagByType(Type type)
		{
			return GetHandlerByType(type)?.Tag;
		}

		public static ModuleMessageHandler GetHandlerByType(Type type)
		{
			if (TypeToHandlerLookup.TryGetValue(type, out var value))
			{
				return value;
			}
			return null;
		}

		public static bool PreRelayMessage(ReceivedMessage received)
		{
			try
			{
				byte[] bytes = received.Bytes;
				long tag = GetTag(bytes);
				if (TagToHandlerLookup.TryGetValue(tag, out var value))
				{
					byte[] buffer = GetBuffer(bytes);
					ReceivedMessage receivedMessage = default(ReceivedMessage);
					receivedMessage.Route = received.Route;
					receivedMessage.Bytes = buffer;
					receivedMessage.IsServerHandled = received.IsServerHandled;
					ReceivedMessage received2 = receivedMessage;
					return value.ProcessPreRelayMessage(received2);
				}
			}
			catch (Exception e)
			{
				FusionLogger.LogException("checking PreRelayMessage", e);
				return false;
			}
			return true;
		}

		public static void ReadMessage(ReceivedMessage received)
		{
			try
			{
				byte[] bytes = received.Bytes;
				long tag = GetTag(bytes);
				if (TagToHandlerLookup.TryGetValue(tag, out var value))
				{
					byte[] buffer = GetBuffer(bytes);
					ReceivedMessage receivedMessage = default(ReceivedMessage);
					receivedMessage.Route = received.Route;
					receivedMessage.Sender = received.Sender;
					receivedMessage.Bytes = buffer;
					receivedMessage.IsServerHandled = received.IsServerHandled;
					ReceivedMessage received2 = receivedMessage;
					value.StartHandlingMessage(received2);
				}
			}
			catch (Exception e)
			{
				FusionLogger.LogException("handling ModuleMessageHandler", e);
			}
		}

		private static long GetTag(byte[] bytes)
		{
			return BinaryPrimitives.ReadInt64BigEndian(bytes);
		}

		private static byte[] GetBuffer(byte[] bytes)
		{
			byte[] array = new byte[bytes.Length - 8];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = bytes[i + 8];
			}
			return array;
		}
	}
}
namespace LabFusion.SDK.Metadata
{
	public static class CommonKeys
	{
		public const string ScoreKey = "Score";

		public const string TeamKey = "Team";

		public const string DamageKey = "Damage";

		public const string LivesKey = "Lives";
	}
	public static class GamemodeKeys
	{
		public const string StartedKey = "Gamemode.Started";

		public const string SelectedKey = "Gamemode.Selected";

		public const string ReadyKey = "Gamemode.Ready";

		public static Predicate<string> PersistentKeys => delegate(string v)
		{
			switch (v)
			{
			case "Gamemode.Started":
			case "Gamemode.Selected":
			case "Gamemode.Ready":
				return true;
			default:
				return false;
			}
		};
	}
	public class MetadataInt : MetadataVariableT<int>
	{
		public MetadataInt(string key, NetworkMetadata metadata)
			: base(key, metadata)
		{
		}

		public void Add(int value)
		{
			SetValue(GetValue() + value);
		}

		public void Subtract(int value)
		{
			SetValue(GetValue() - value);
		}
	}
	public class MetadataFloat : MetadataVariableT<float>
	{
		public MetadataFloat(string key, NetworkMetadata metadata)
			: base(key, metadata)
		{
		}

		public void Add(float value)
		{
			SetValue(GetValue() + value);
		}

		public void Subtract(float value)
		{
			SetValue(GetValue() - value);
		}

		public void Multiply(float value)
		{
			SetValue(GetValue() * value);
		}

		public void Divide(float value)
		{
			SetValue(GetValue() / value);
		}
	}
	public class MetadataBool : MetadataVariableT<bool>
	{
		public MetadataBool(string key, NetworkMetadata metadata)
			: base(key, metadata)
		{
		}

		public void Toggle()
		{
			SetValue(!GetValue());
		}
	}
	public class MetadataVector3 : MetadataVariable
	{
		public MetadataVector3(string key, NetworkMetadata metadata)
			: base(key, metadata)
		{
		}

		public void SetValue(Vector3 value)
		{
			base.SetValue(JsonUtility.ToJson(((Vector3)(ref value)).BoxIl2CppObject()));
		}

		public new Vector3 GetValue()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return JsonUtility.FromJson<Vector3>(base.GetValue());
		}

		public void Add(Vector3 value)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SetValue(GetValue() + value);
		}

		public void Subtract(Vector3 value)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SetValue(GetValue() - value);
		}

		public void Multiply(float value)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SetValue(GetValue() * value);
		}

		public void Divide(float value)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SetValue(GetValue() / value);
		}
	}
	public static class KeyHelper
	{
		public const string PropertySeparator = ":";

		public static bool KeyMatchesVariable(string key, string variable)
		{
			int num = key.LastIndexOf(":");
			if (num < 0)
			{
				return key == variable;
			}
			return key.Substring(0, num) == variable;
		}

		public static string GetKeyWithProperty(string variable, string property)
		{
			return variable + ":" + property;
		}

		public static string GetPropertyFromKey(string key)
		{
			int num = key.LastIndexOf(":") + 1;
			return key.Substring(num, key.Length - num);
		}

		public static string GetKeyFromPlayer(string variable, byte smallID)
		{
			return GetKeyWithProperty(variable, smallID.ToString());
		}

		public static byte GetPlayerFromKey(string key)
		{
			string propertyFromKey = GetPropertyFromKey(key);
			if (!byte.TryParse(propertyFromKey, out var result))
			{
				throw new FormatException($"Key {key} was not in the correct format. (Property: {propertyFromKey})");
			}
			return result;
		}
	}
	public abstract class MetadataDictionary<TProperty, TVariable> where TVariable : MetadataVariable
	{
		private readonly Dictionary<TProperty, TVariable> _propertyToVariable = new Dictionary<TProperty, TVariable>();

		private NetworkMetadata _metadata;

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


		public event Action<TProperty, TVariable> OnVariableChanged;

		public abstract string GetKeyWithProperty(TProperty property);

		public abstract TProperty GetPropertyWithKey(string key);

		public void Register(NetworkMetadata metadata, string key)
		{
			_metadata = metadata;
			_metadata.OnMetadataChanged += OnMetadataChanged;
			_metadata.OnMetadataRemoved += OnMetadataRemoved;
			Key = key;
			OnRegistered();
		}

		public void Unregister()
		{
			_metadata.OnMetadataChanged -= OnMetadataChanged;
			_metadata = null;
			Key = string.Empty;
			OnUnregistered();
		}

		protected virtual void OnRegistered()
		{
		}

		protected virtual void OnUnregistered()
		{
		}

		private void OnMetadataChanged(string key, string value)
		{
			if (KeyHelper.KeyMatchesVariable(key, Key))
			{
				TProperty propertyWithKey = GetPropertyWithKey(key);
				if (propertyWithKey != null)
				{
					TVariable variable = GetVariable(propertyWithKey);
					this.OnVariableChanged?.InvokeSafe(propertyWithKey, variable, "executing MetadataDictionary.OnVariableChanged");
				}
			}
		}

		private void OnMetadataRemoved(string key, string value)
		{
			if (!KeyHelper.KeyMatchesVariable(key, Key))
			{
				return;
			}
			foreach (KeyValuePair<TProperty, TVariable> item in _propertyToVariable.Where((KeyValuePair<TProperty, TVariable> pair) => pair.Value.Key == key).ToList())
			{
				if (item.Key != null)
				{
					_propertyToVariable.Remove(item.Key);
				}
			}
		}

		public TVariable GetVariable(TProperty property)
		{
			if (property == null)
			{
				return null;
			}
			if (!_propertyToVariable.TryGetValue(property, out var value))
			{
				value = Activator.CreateInstance(typeof(TVariable), GetKeyWithProperty(property), _metadata) as TVariable;
				_propertyToVariable[property] = value;
			}
			return value;
		}

		public void RemoveVariable(TProperty property)
		{
			if (property != null)
			{
				_propertyToVariable.Remove(property);
			}
		}

		public void Clear()
		{
			foreach (TVariable value in _propertyToVariable.Values)
			{
				value.Remove();
			}
		}
	}
	public class MetadataPlayerDictionary<TVariable> : MetadataDictionary<byte, TVariable> where TVariable : MetadataVariable
	{
		public event Action<PlayerID, TVariable> OnPlayerVariableChanged;

		protected override void OnRegistered()
		{
			base.OnVariableChanged += OnByteVariableChanged;
			MultiplayerHooking.OnPlayerLeft += OnPlayerLeft;
		}

		protected override void OnUnregistered()
		{
			base.OnVariableChanged -= OnByteVariableChanged;
			MultiplayerHooking.OnPlayerLeft -= OnPlayerLeft;
		}

		private void OnByteVariableChanged(byte smallID, TVariable variable)
		{
			PlayerID playerID = PlayerIDManager.GetPlayerID(smallID);
			if (playerID != null)
			{
				this.OnPlayerVariableChanged?.InvokeSafe(playerID, variable, "executing MetadataPlayerDictionary.OnPlayerVariableChanged");
			}
		}

		private void OnPlayerLeft(PlayerID playerID)
		{
			RemoveVariable(playerID);
		}

		public override string GetKeyWithProperty(byte property)
		{
			return KeyHelper.GetKeyFromPlayer(base.Key, property);
		}

		public override byte GetPropertyWithKey(string key)
		{
			return KeyHelper.GetPlayerFromKey(key);
		}

		public TVariable GetVariable(PlayerID playerID)
		{
			return GetVariable(playerID.SmallID);
		}

		public void RemoveVariable(PlayerID playerID)
		{
			RemoveVariable(playerID.SmallID);
		}
	}
	public class MetadataVariable
	{
		private static readonly JsonSerializerOptions SerializerOptions = new JsonSerializerOptions
		{
			IncludeFields = true
		};

		public NetworkMetadata Metadata { get; }

		public string Key { get; }

		public MetadataVariable(string key, NetworkMetadata metadata)
		{
			Key = key;
			Metadata = metadata;
		}

		public void Remove()
		{
			Metadata.TryRemoveMetadata(Key);
		}

		public void SetValue(string value)
		{
			Metadata.TrySetMetadata(Key, value);
		}

		public void SetValue<TValue>(TValue value)
		{
			SetValue(JsonSerializer.Serialize(value, SerializerOptions));
		}

		public string GetValue()
		{
			return Metadata.GetMetadata(Key);
		}

		public string GetValueOrEmpty()
		{
			string value = GetValue();
			if (string.IsNullOrWhiteSpace(value))
			{
				return string.Empty;
			}
			return value;
		}

		public TValue GetValue<TValue>()
		{
			string value = GetValue();
			if (string.IsNullOrEmpty(value))
			{
				return default(TValue);
			}
			return JsonSerializer.Deserialize<TValue>(value, SerializerOptions);
		}
	}
	public class MetadataVariableT<TValue> : MetadataVariable
	{
		public MetadataVariableT(string key, NetworkMetadata metadata)
			: base(key, metadata)
		{
		}

		public void SetValue(TValue value)
		{
			base.SetValue(value);
		}

		public new TValue GetValue()
		{
			return GetValue<TValue>();
		}
	}
	public delegate bool MetadataSetDelegate(string key, string value);
	public delegate bool MetadataRemoveDelegate(string key);
	public class NetworkMetadata
	{
		private readonly Dictionary<string, string> _localDictionary = new Dictionary<string, string>();

		public MetadataSetDelegate OnTrySetMetadata;

		public MetadataRemoveDelegate OnTryRemoveMetadata;

		public Dictionary<string, string> LocalDictionary => _localDictionary;

		public event Action<string, string> OnMetadataChanged;

		public event Action<string, string> OnMetadataRemoved;

		public bool TrySetMetadata(string key, string value)
		{
			if (OnTrySetMetadata == null)
			{
				FusionLogger.Warn($"Tried setting metadata with a key of {key} and value of {value}, but the request callbacks were not set!");
				return false;
			}
			return OnTrySetMetadata(key, value);
		}

		public bool TryRemoveMetadata(string key)
		{
			if (OnTryRemoveMetadata == null)
			{
				FusionLogger.Warn("Tried removing metadata with a key of " + key + ", but the request callbacks were not set!");
				return false;
			}
			return OnTryRemoveMetadata(key);
		}

		public bool TryGetMetadata(string key, out string value)
		{
			return _localDictionary.TryGetValue(key, out value);
		}

		public string GetMetadata(string key)
		{
			if (_localDictionary.TryGetValue(key, out var value))
			{
				return value;
			}
			return null;
		}

		public void ForceSetLocalMetadata(string key, string value)
		{
			_localDictionary[key] = value;
			this.OnMetadataChanged?.InvokeSafe(key, value, "executing OnMetadataChanged");
		}

		public void ForceRemoveLocalMetadata(string key)
		{
			if (_localDictionary.TryGetValue(key, out var value))
			{
				this.OnMetadataRemoved?.InvokeSafe(key, value, "executing OnMetadataRemoved");
				_localDictionary.Remove(key);
			}
		}

		public void ClearLocalMetadata()
		{
			string[] array = _localDictionary.Keys.ToArray();
			foreach (string text in array)
			{
				this.OnMetadataRemoved?.InvokeSafe(text, _localDictionary[text], "executing OnMetadataRemoved");
				_localDictionary.Remove(text);
			}
		}

		public void ClearLocalMetadataExcept(Predicate<string> predicate)
		{
			string[] array = _localDictionary.Keys.ToArray();
			foreach (string text in array)
			{
				if (!predicate(text))
				{
					this.OnMetadataRemoved?.InvokeSafe(text, _localDictionary[text], "executing OnMetadataRemoved");
					_localDictionary.Remove(text);
				}
			}
		}
	}
}
namespace LabFusion.SDK.Messages
{
	public class AnimationStateData : LabFusion.Network.Serialization.INetSerializable
	{
		public ComponentPathData ComponentData;

		public int StateNameHash;

		public int Layer;

		public float NormalizedTime;

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref ComponentData);
			serializer.SerializeValue(ref StateNameHash);
			serializer.SerializeValue(ref Layer);
			serializer.SerializeValue(ref NormalizedTime);
		}
	}
	public class AnimationStateMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			AnimationStateData animationStateData = received.ReadData<AnimationStateData>();
			if (animationStateData.ComponentData.TryGetComponent<AnimatorSyncer, AnimatorSyncerExtender>(AnimatorSyncer.HashTable, out AnimatorSyncer component))
			{
				OnFoundAnimatorSyncer(component, animationStateData);
			}
		}

		private static void OnFoundAnimatorSyncer(AnimatorSyncer syncer, AnimationStateData data)
		{
			syncer.ApplyAnimationState(data);
		}
	}
	public class GamemodeDropperData : LabFusion.Network.Serialization.INetSerializable
	{
		public NetworkEntityReference Entity;

		public int? GetSize()
		{
			return Entity.GetSize();
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref Entity);
		}
	}
	[Net.DelayWhileTargetLoading]
	public class GamemodeDropperMessage : ModuleMessageHandler
	{
		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ClientsOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			if (received.ReadData<GamemodeDropperData>().Entity.TryGetEntity(out var entity))
			{
				NetworkProp extender = entity.GetExtender<NetworkProp>();
				PooleeExtender extender2 = entity.GetExtender<PooleeExtender>();
				if (extender != null && extender2 != null)
				{
					((Component)extender.MarrowEntity).gameObject.AddComponent<GamemodeItem>().Initialize(entity, extender2.Component);
				}
			}
		}
	}
	public class VoiceProxyInputData : LabFusion.Network.Serialization.INetSerializable
	{
		public ComponentPathData ComponentData;

		public byte PlayerID;

		public bool Input;

		public int? GetSize()
		{
			return 16;
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref ComponentData);
			serializer.SerializeValue(ref PlayerID);
			serializer.SerializeValue(ref Input);
		}
	}
	public class VoiceProxyInputMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			VoiceProxyInputData voiceProxyInputData = received.ReadData<VoiceProxyInputData>();
			if (voiceProxyInputData.ComponentData.TryGetComponent<VoiceProxy, VoiceProxyExtender>(VoiceProxy.HashTable, out VoiceProxy component))
			{
				OnFoundVoiceProxy(component, voiceProxyInputData);
			}
		}

		private static void OnFoundVoiceProxy(VoiceProxy proxy, VoiceProxyInputData data)
		{
			if (data.Input)
			{
				proxy.InputID = data.PlayerID;
			}
			else
			{
				proxy.InputID = null;
			}
		}
	}
}
namespace LabFusion.SDK.Lobbies
{
	public delegate bool GenericLobbyDelegate(INetworkLobby lobby, LobbyMetadataInfo info);
	public class GenericLobbyFilter : ILobbyFilter
	{
		public GenericLobbyDelegate OnFilter;

		public string Title;

		private bool _active;

		public GenericLobbyFilter(string title, GenericLobbyDelegate onFilter)
		{
			Title = title;
			OnFilter = onFilter;
		}

		public bool FilterLobby(INetworkLobby lobby, LobbyMetadataInfo info)
		{
			return OnFilter(lobby, info);
		}

		public string GetTitle()
		{
			return Title;
		}

		public bool IsActive()
		{
			return _active;
		}

		public void SetActive(bool active)
		{
			_active = active;
		}
	}
	public interface ILobbyFilter
	{
		string GetTitle();

		bool IsActive();

		void SetActive(bool active);

		bool FilterLobby(INetworkLobby lobby, LobbyMetadataInfo info);
	}
	public static class LobbyFilterManager
	{
		private static readonly List<ILobbyFilter> _lobbyFilters = new List<ILobbyFilter>();

		public static List<ILobbyFilter> LobbyFilters => _lobbyFilters;

		public static GenericLobbyFilter FullFilter { get; } = new GenericLobbyFilter("Hide Full Lobbies", (INetworkLobby l, LobbyMetadataInfo i) => i.LobbyInfo.MaxPlayers > i.LobbyInfo.PlayerCount);


		public static GenericLobbyFilter MismatchingVersionsFilter { get; } = new GenericLobbyFilter("Hide Mismatching Versions", (INetworkLobby l, LobbyMetadataInfo i) => NetworkVerification.CompareVersion(i.LobbyInfo.LobbyVersion, FusionMod.Version) == VersionResult.Ok);


		public static GenericLobbyFilter FriendsFilter { get; } = new GenericLobbyFilter("Friends Only", (INetworkLobby l, LobbyMetadataInfo i) => NetworkLayerManager.Layer.IsFriend(i.LobbyInfo.LobbyID));


		public static event Action<ILobbyFilter> OnAddedFilter;

		public static void LoadBuiltInFilters()
		{
			FullFilter.SetActive(active: true);
			AddLobbyFilter(FullFilter);
			MismatchingVersionsFilter.SetActive(active: true);
			AddLobbyFilter(MismatchingVersionsFilter);
			AddLobbyFilter(FriendsFilter);
		}

		public static void AddLobbyFilter(ILobbyFilter filter)
		{
			_lobbyFilters.Add(filter);
			LobbyFilterManager.OnAddedFilter?.Invoke(filter);
		}

		public static bool CheckOptionalFilters(INetworkLobby lobby, LobbyMetadataInfo info)
		{
			foreach (ILobbyFilter lobbyFilter in LobbyFilters)
			{
				if (lobbyFilter.IsActive() && !lobbyFilter.FilterLobby(lobby, info))
				{
					return false;
				}
			}
			return true;
		}

		public static bool CheckPersistentFilters(INetworkLobby lobby, LobbyMetadataInfo info)
		{
			if (GlobalBanManager.IsBanned(info.LobbyInfo))
			{
				return false;
			}
			return true;
		}

		public static MatchmakerFilters CreateMatchmakerFilters()
		{
			MatchmakerFilters result = default(MatchmakerFilters);
			result.FilterFull = FullFilter.IsActive();
			result.FilterMismatchingVersions = MismatchingVersionsFilter.IsActive();
			return result;
		}
	}
}
namespace LabFusion.SDK.Gamemodes
{
	public class Deathmatch : Gamemode
	{
		private const int _minPlayerBits = 60;

		private const int _maxPlayerBits = 600;

		private const int _defaultMinutes = 3;

		private const int _minMinutes = 2;

		private const int _maxMinutes = 60;

		private readonly PlayerScoreKeeper _scoreKeeper = new PlayerScoreKeeper();

		private readonly MusicPlaylist _playlist = new MusicPlaylist();

		private bool _hasDied;

		private float _timeOfStart;

		private bool _oneMinuteLeft;

		private int _savedMinutes = 3;

		private int _totalMinutes = 3;

		private int _minimumPlayers = 2;

		private float _savedVitality = 1f;

		private string _avatarOverride;

		private MonoDiscReference _victorySongReference;

		private MonoDiscReference _failureSongReference;

		public override string Title => "Deathmatch";

		public override string Author => "Lakatrazz";

		public override string Description => "All players are pitted against each other in a free for all! Kill other players to gain points before the timer runs out! More Bits are given based on the amount of players you kill compared to other players.";

		public override Texture Logo => MenuResources.GetGamemodeIcon(Title);

		public override bool DisableDevTools => true;

		public override bool DisableSpawnGun => true;

		public override bool DisableManualUnragdoll => true;

		public TriggerEvent OneMinuteLeftTrigger { get; set; }

		public TriggerEvent NaturalEndTrigger { get; set; }

		public MetadataFloat Vitality { get; set; }

		public PlayerScoreKeeper ScoreKeeper => _scoreKeeper;

		public MusicPlaylist Playlist => _playlist;

		public int MinimumPlayers
		{
			get
			{
				return _minimumPlayers;
			}
			set
			{
				_minimumPlayers = value;
				if (!base.IsStarted && base.IsSelected)
				{
					GamemodeManager.ValidateReadyConditions();
				}
			}
		}

		public override GroupElementData CreateSettingsGroup()
		{
			GroupElementData groupElementData = base.CreateSettingsGroup();
			GroupElementData groupElementData2 = new GroupElementData("General");
			groupElementData.AddElement(groupElementData2);
			IntElementData element = new IntElementData
			{
				Title = "Round Minutes",
				Value = _totalMinutes,
				Increment = 1,
				MinValue = 2,
				MaxValue = 60,
				OnValueChanged = delegate(int v)
				{
					_totalMinutes = v;
					_savedMinutes = v;
				}
			};
			groupElementData2.AddElement(element);
			IntElementData element2 = new IntElementData
			{
				Title = "Minimum Players",
				Value = MinimumPlayers,
				Increment = 1,
				MinValue = 1,
				MaxValue = 255,
				OnValueChanged = delegate(int v)
				{
					MinimumPlayers = v;
				}
			};
			groupElementData2.AddElement(element2);
			FloatElementData element3 = new FloatElementData
			{
				Title = "Vitality",
				Value = _savedVitality,
				Increment = 0.2f,
				MinValue = 0.2f,
				MaxValue = 100f,
				OnValueChanged = delegate(float v)
				{
					_savedVitality = v;
				}
			};
			groupElementData2.AddElement(element3);
			return groupElementData;
		}

		public void ApplyGamemodeSettings()
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			_totalMinutes = _savedMinutes;
			_victorySongReference = FusionMonoDiscReferences.LavaGangVictoryReference;
			_failureSongReference = FusionMonoDiscReferences.LavaGangFailureReference;
			MonoDiscReference[] array = FusionMonoDiscReferences.CombatSongReferences;
			GamemodeMusicSettings instance = GamemodeMusicSettings.Instance;
			if ((Object)(object)instance != (Object)null && instance.SongOverrides.Count > 0)
			{
				array = (MonoDiscReference[])(object)new MonoDiscReference[instance.SongOverrides.Count];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = new MonoDiscReference(instance.SongOverrides[i]);
				}
			}
			if ((Object)(object)instance != (Object)null && !string.IsNullOrWhiteSpace(instance.VictorySongOverride))
			{
				_victorySongReference = new MonoDiscReference(instance.VictorySongOverride);
			}
			if ((Object)(object)instance != (Object)null && !string.IsNullOrWhiteSpace(instance.FailureSongOverride))
			{
				_failureSongReference = new MonoDiscReference(instance.FailureSongOverride);
			}
			AudioReference[] playlist = AudioReference.CreateReferences(array);
			Playlist.SetPlaylist(playlist);
			Playlist.Shuffle();
			_avatarOverride = null;
			float value = _savedVitality;
			GamemodePlayerSettings instance2 = GamemodePlayerSettings.Instance;
			if ((Object)(object)instance2 != (Object)null)
			{
				_avatarOverride = instance2.AvatarOverride;
				if (instance2.VitalityOverride.HasValue)
				{
					value = instance2.VitalityOverride.Value;
				}
			}
			Vitality.SetValue(value);
		}

		private int GetRewardedBits()
		{
			float t = (float)(PlayerIDManager.PlayerCount - 1) / 3f;
			int num = ManagedMathf.FloorToInt(ManagedMathf.Lerp(60f, 600f, t));
			int num2 = num / 10;
			int score = ScoreKeeper.GetScore(PlayerIDManager.LocalID);
			int totalScore = ScoreKeeper.GetTotalScore();
			if (totalScore <= 0)
			{
				return 0;
			}
			float num3 = ManagedMathf.Clamp01((float)score / (float)totalScore);
			int num4 = ManagedMathf.FloorToInt((float)num * num3);
			num4 += Random.Range(-num2, num2);
			if (num4.IsNaN())
			{
				FusionLogger.ErrorLine("Prevented attempt to give invalid bit reward. Please notify a Fusion developer and send them your log.", 230);
				return 0;
			}
			return num4;
		}

		public override void OnGamemodeRegistered()
		{
			MultiplayerHooking.OnPlayerAction += OnPlayerAction;
			FusionOverrides.OnValidateNametag += OnValidateNametag;
			OneMinuteLeftTrigger = new TriggerEvent("OneMinuteLeftTrigger", base.Relay, serverOnly: true);
			OneMinuteLeftTrigger.OnTriggered += OnOneMinuteLeft;
			NaturalEndTrigger = new TriggerEvent("NaturalEndTrigger", base.Relay, serverOnly: true);
			NaturalEndTrigger.OnTriggered += OnNaturalEnd;
			Vitality = new MetadataFloat("Vitality", base.Metadata);
			base.Metadata.OnMetadataChanged += OnMetadataChanged;
			ScoreKeeper.Register(base.Metadata);
			ScoreKeeper.OnPlayerScoreChanged += OnScoreChanged;
		}

		public override void OnGamemodeUnregistered()
		{
			MultiplayerHooking.OnPlayerAction -= OnPlayerAction;
			FusionOverrides.OnValidateNametag -= OnValidateNametag;
			base.Metadata.OnMetadataChanged -= OnMetadataChanged;
			OneMinuteLeftTrigger.UnregisterEvent();
			NaturalEndTrigger.UnregisterEvent();
			ScoreKeeper.Unregister();
			ScoreKeeper.OnPlayerScoreChanged -= OnScoreChanged;
		}

		private new void OnMetadataChanged(string key, string value)
		{
			if (key == "Vitality")
			{
				OnApplyVitality();
			}
		}

		protected bool OnValidateNametag(PlayerID id)
		{
			if (!base.IsStarted)
			{
				return true;
			}
			return false;
		}

		protected void OnPlayerAction(PlayerID player, PlayerActionType type, PlayerID otherPlayer = null)
		{
			if (!base.IsStarted)
			{
				return;
			}
			switch (type)
			{
			case PlayerActionType.DEATH:
				if (player.IsMe)
				{
					_hasDied = true;
				}
				break;
			case PlayerActionType.DYING_BY_OTHER_PLAYER:
				if (otherPlayer != null && otherPlayer != player)
				{
					if (NetworkInfo.IsHost)
					{
						ScoreKeeper.AddScore(otherPlayer);
					}
					if (otherPlayer.IsMe)
					{
						AchievementManager.IncrementAchievements<KillerAchievement>();
					}
				}
				break;
			}
		}

		public override bool CheckReadyConditions()
		{
			return PlayerIDManager.PlayerCount >= MinimumPlayers;
		}

		public override void OnGamemodeStarted()
		{
			base.OnGamemodeStarted();
			if (NetworkInfo.IsHost)
			{
				ScoreKeeper.ResetScores();
			}
			Notifier.Send(new Notification
			{
				Title = "Deathmatch Started",
				Message = "Good luck!",
				SaveToMenu = false,
				ShowPopup = true
			});
			_timeOfStart = TimeReferences.TimeSinceStartup;
			_oneMinuteLeft = false;
			_hasDied = false;
			LocalHealth.MortalityOverride = true;
			LocalControls.DisableSlowMo = true;
			if (_avatarOverride != null)
			{
				LocalAvatar.AvatarOverride = _avatarOverride;
			}
			OnApplyVitality();
		}

		public override void OnLevelReady()
		{
			ApplyGamemodeSettings();
			Playlist.StartPlaylist();
			LocalInventory.SetAmmo(10000);
			GamemodeHelper.SetSpawnPoints(GamemodeMarker.FilterMarkers());
			GamemodeHelper.TeleportToSpawnPoint();
			FusionOverrides.ForceUpdateOverrides();
		}

		private void OnApplyVitality()
		{
			if (base.IsStarted)
			{
				LocalHealth.VitalityOverride = Vitality.GetValue();
			}
		}

		protected void OnVictoryStatus(bool isVictory = false)
		{
			MonoDiscReference val = ((!isVictory) ? _failureSongReference : _victorySongReference);
			if (val != null)
			{
				LocalAudioPlayer.Play2dOneShot(new AudioReference(val), LocalAudioPlayer.MusicSettings);
			}
		}

		public override void OnGamemodeStopped()
		{
			base.OnGamemodeStopped();
			Playlist.StopPlaylist();
			PlayerID playerByPlace = ScoreKeeper.GetPlayerByPlace(0);
			PlayerID playerByPlace2 = ScoreKeeper.GetPlayerByPlace(1);
			PlayerID playerByPlace3 = ScoreKeeper.GetPlayerByPlace(2);
			int place = ScoreKeeper.GetPlace(PlayerIDManager.LocalID);
			int score = ScoreKeeper.GetScore(PlayerIDManager.LocalID);
			string text = "No one scored points!";
			if (playerByPlace != null && playerByPlace.TryGetDisplayName(out var name))
			{
				text = $"First Place: {name} (Score: {ScoreKeeper.GetScore(playerByPlace)}) \n";
			}
			if (playerByPlace2 != null && playerByPlace2.TryGetDisplayName(out name))
			{
				text += $"Second Place: {name} (Score: {ScoreKeeper.GetScore(playerByPlace2)}) \n";
			}
			if (playerByPlace3 != null && playerByPlace3.TryGetDisplayName(out name))
			{
				text += $"Third Place: {name} (Score: {ScoreKeeper.GetScore(playerByPlace3)}) \n";
			}
			if (place != -1 && place > 3)
			{
				text += $"Your Place: {place} (Score: {score})";
			}
			int playerCount = PlayerIDManager.PlayerCount;
			if (playerCount > 1)
			{
				bool isVictory = false;
				if (place < System.Math.Min(playerCount, 3))
				{
					isVictory = true;
				}
				OnVictoryStatus(isVictory);
				if (place == 1 && !_hasDied && AchievementManager.TryGetAchievement<Rampage>(out var achievement))
				{
					achievement.IncrementTask();
				}
			}
			Notifier.Send(new Notification
			{
				Title = "Deathmatch Completed",
				Message = text,
				PopupLength = 6f,
				SaveToMenu = false,
				ShowPopup = true
			});
			_timeOfStart = 0f;
			_oneMinuteLeft = false;
			LocalHealth.MortalityOverride = null;
			FusionPlayer.ResetSpawnPoints();
			FusionOverrides.ForceUpdateOverrides();
			LocalAvatar.AvatarOverride = null;
			LocalHealth.VitalityOverride = null;
			LocalControls.DisableSlowMo = false;
		}

		public float GetTimeElapsed()
		{
			return TimeReferences.TimeSinceStartup - _timeOfStart;
		}

		public float GetMinutesLeft()
		{
			float timeElapsed = GetTimeElapsed();
			return (float)_totalMinutes - timeElapsed / 60f;
		}

		protected override void OnUpdate()
		{
			if (!base.IsStarted)
			{
				return;
			}
			Playlist.Update();
			if (NetworkInfo.IsHost)
			{
				float minutesLeft = GetMinutesLeft();
				if (!_oneMinuteLeft && minutesLeft <= 1f)
				{
					OneMinuteLeftTrigger.TryInvoke();
					_oneMinuteLeft = true;
				}
				if (minutesLeft <= 0f)
				{
					GamemodeManager.StopGamemode();
					NaturalEndTrigger.TryInvoke();
				}
			}
		}

		private void OnOneMinuteLeft()
		{
			Notifier.Send(new Notification
			{
				Title = "Deathmatch Timer",
				Message = "One minute left!",
				SaveToMenu = false,
				ShowPopup = true
			});
		}

		private void OnNaturalEnd()
		{
			int rewardedBits = GetRewardedBits();
			if (rewardedBits > 0)
			{
				PointItemManager.RewardBits(rewardedBits);
			}
		}

		private void OnScoreChanged(PlayerID player, int score)
		{
			if (player.IsMe && score != 0)
			{
				Notifier.Send(new Notification
				{
					Title = "Deathmatch Point",
					Message = $"New score is {score}!",
					SaveToMenu = false,
					ShowPopup = true,
					PopupLength = 0.7f
				});
			}
		}
	}
	public class Entangled : Gamemode
	{
		public class EntangledTether
		{
			public PlayerID player1;

			public PlayerID player2;

			public Rigidbody selfPelvis;

			public Rigidbody otherPelvis;

			public ConfigurableJoint joint;

			public GameObject lineInstance;

			public EntangledTether(PlayerID player1, PlayerID player2)
			{
				this.player1 = player1;
				this.player2 = player2;
				((CrateT<GameObject>)(object)((CrateReferenceT<SpawnableCrate>)(object)FusionSpawnableReferences.EntangledLineReference).Crate).LoadAsset(Action<GameObject>.op_Implicit((Action<GameObject>)delegate(GameObject prefab)
				{
					lineInstance = Object.Instantiate<GameObject>(prefab);
					Object.DontDestroyOnLoad((Object)(object)lineInstance);
					((Object)lineInstance).hideFlags = (HideFlags)32;
				}));
			}

			public void Dispose()
			{
				if ((Object)(object)joint != (Object)null)
				{
					Object.Destroy((Object)(object)joint);
				}
				if ((Object)(object)lineInstance != (Object)null)
				{
					Object.Destroy((Object)(object)lineInstance);
				}
			}

			public bool IsValid()
			{
				if (!PlayerID.IsNullOrInvalid(player1))
				{
					return !PlayerID.IsNullOrInvalid(player2);
				}
				return false;
			}

			public void OnUpdate()
			{
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_0157: Unknown result type (might be due to invalid IL or missing references)
				if (FusionSceneManager.IsLoading() || !IsValid())
				{
					return;
				}
				if ((Object)(object)selfPelvis == (Object)null && PlayerRepUtilities.TryGetReferences(player1, out var references) && references.IsValid)
				{
					selfPelvis = references.RigManager.physicsRig.torso._pelvisRb;
				}
				if ((Object)(object)otherPelvis == (Object)null && PlayerRepUtilities.TryGetReferences(player2, out var references2) && references2.IsValid)
				{
					otherPelvis = references2.RigManager.physicsRig.torso._pelvisRb;
				}
				if ((Object)(object)selfPelvis != (Object)null && (Object)(object)otherPelvis != (Object)null)
				{
					if ((Object)(object)joint == (Object)null)
					{
						CreateJoint();
					}
					lineInstance.SetActive(true);
					lineInstance.transform.position = selfPelvis.position;
					Vector3 vector = otherPelvis.position - selfPelvis.position;
					lineInstance.transform.rotation = Quaternion.LookRotation(Vector3Extensions.Normalize(vector));
					Vector3 localScale = lineInstance.transform.localScale;
					localScale.z = Vector3Extensions.GetMagnitude(vector);
					lineInstance.transform.localScale = localScale;
				}
				else
				{
					lineInstance.SetActive(false);
				}
			}

			private void CreateJoint()
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				joint = ((Component)selfPelvis).gameObject.AddComponent<ConfigurableJoint>();
				ConfigurableJoint obj = joint;
				ConfigurableJoint obj2 = joint;
				ConfigurableJoint obj3 = joint;
				ConfigurableJointMotion val = (ConfigurableJointMotion)1;
				obj3.zMotion = (ConfigurableJointMotion)1;
				ConfigurableJointMotion xMotion = (obj2.yMotion = val);
				obj.xMotion = xMotion;
				ConfigurableJoint obj4 = joint;
				SoftJointLimit linearLimit = default(SoftJointLimit);
				((SoftJointLimit)(ref linearLimit)).limit = 3f;
				obj4.linearLimit = linearLimit;
				ConfigurableJoint obj5 = joint;
				SoftJointLimitSpring linearLimitSpring = default(SoftJointLimitSpring);
				((SoftJointLimitSpring)(ref linearLimitSpring)).spring = 7000f;
				obj5.linearLimitSpring = linearLimitSpring;
				((Joint)joint).autoConfigureConnectedAnchor = false;
				((Joint)joint).anchor = Vector3Extensions.zero;
				((Joint)joint).connectedAnchor = Vector3Extensions.zero;
				((Joint)joint).connectedBody = otherPelvis;
			}
		}

		public const string DefaultPrefix = "InternalEntangledMetadata";

		public const string PlayerPartnerKey = "InternalEntangledMetadata.Partner";

		private readonly MusicPlaylist _playlist = new MusicPlaylist();

		protected PlayerID _partner;

		protected List<EntangledTether> _tethers = new List<EntangledTether>();

		public static Entangled Instance { get; private set; }

		public override string Title => "Entangled";

		public override string Author => "Lakatrazz";

		public override string Description => "Get tethered to a random player! No objectives except to mess around!";

		public override Texture Logo => MenuResources.GetGamemodeIcon(Title);

		public override bool AutoStopOnSceneLoad => false;

		public override bool DisableSpawnGun => false;

		public override bool DisableDevTools => false;

		public override bool DisableManualUnragdoll => false;

		public MusicPlaylist Playlist => _playlist;

		public override void OnGamemodeRegistered()
		{
			Instance = this;
			SetDefaultValues();
		}

		public override void OnMainSceneInitialized()
		{
			SetDefaultValues();
		}

		public void SetDefaultValues()
		{
			AudioReference audioReference = new AudioReference(FusionMonoDiscReferences.GeoGrpFellDownTheStairsReference);
			Playlist.SetPlaylist(audioReference);
		}

		public override void OnGamemodeUnregistered()
		{
			if (Instance == this)
			{
				Instance = null;
			}
			_partner = null;
			foreach (EntangledTether tether in _tethers)
			{
				tether.Dispose();
			}
			_tethers.Clear();
		}

		protected override void OnUpdate()
		{
			if (!base.IsStarted)
			{
				return;
			}
			Playlist.Update();
			foreach (EntangledTether tether in _tethers)
			{
				tether.OnUpdate();
			}
		}

		protected override void OnPlayerJoined(PlayerID id)
		{
			List<PlayerID> unassignedPlayers = GetUnassignedPlayers();
			if (unassignedPlayers.Count > 0)
			{
				AssignPartners(unassignedPlayers[0], id);
			}
			else
			{
				AssignPartners(id, null);
			}
		}

		protected override void OnPlayerLeft(PlayerID id)
		{
			RemovePartners(id);
		}

		public override void OnGamemodeStarted()
		{
			base.OnGamemodeStarted();
			Playlist.StartPlaylist();
			if (NetworkInfo.IsHost)
			{
				List<PlayerID> unassignedPlayers = GetUnassignedPlayers();
				while (unassignedPlayers.Count > 1)
				{
					unassignedPlayers.Shuffle();
					PlayerID playerID = unassignedPlayers[0];
					PlayerID playerID2 = unassignedPlayers[1];
					AssignPartners(playerID, playerID2);
					unassignedPlayers.Remove(playerID);
					unassignedPlayers.Remove(playerID2);
				}
				if (unassignedPlayers.Count > 0)
				{
					AssignPartners(unassignedPlayers[0], null);
				}
			}
		}

		public override void OnGamemodeStopped()
		{
			base.OnGamemodeStopped();
			Playlist.StopPlaylist();
			Notifier.Send(new Notification
			{
				Title = "Entangled Finish",
				Message = "The gamemode has ended!",
				SaveToMenu = false,
				ShowPopup = true,
				PopupLength = 2f
			});
			if (NetworkInfo.IsHost)
			{
				foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
				{
					RemovePartners(playerID);
				}
			}
			_partner = null;
			foreach (EntangledTether tether in _tethers)
			{
				tether.Dispose();
			}
			_tethers.Clear();
		}

		protected List<PlayerID> GetUnassignedPlayers()
		{
			List<PlayerID> list = new List<PlayerID>();
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				if (GetPartner(playerID) == null)
				{
					list.Add(playerID);
				}
			}
			return list;
		}

		protected void AssignPartners(PlayerID player1, PlayerID player2)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if (player2 == null)
			{
				base.Metadata.TrySetMetadata(GetPartnerKey(player1), "-1");
				return;
			}
			base.Metadata.TrySetMetadata(GetPartnerKey(player1), player2.PlatformID.ToString());
			base.Metadata.TrySetMetadata(GetPartnerKey(player2), player1.PlatformID.ToString());
			if (NetworkPlayerManager.TryGetPlayer((byte)player2, out NetworkPlayer player3) && player3.HasRig)
			{
				PlayerSender.SendPlayerTeleport(player1, player3.RigRefs.RigManager.physicsRig._feetRb.position);
			}
		}

		protected void RemovePartners(PlayerID player1)
		{
			PlayerID partner = GetPartner(player1);
			base.Metadata.TryRemoveMetadata(GetPartnerKey(player1));
			if (partner != null)
			{
				base.Metadata.TryRemoveMetadata(GetPartnerKey(partner));
			}
		}

		protected string GetPartnerKey(PlayerID id)
		{
			return $"{"InternalEntangledMetadata.Partner"}.{id.PlatformID}";
		}

		protected PlayerID GetPartner(PlayerID id)
		{
			if (base.Metadata.TryGetMetadata(GetPartnerKey(id), out var value) && ulong.TryParse(value, out var result))
			{
				return PlayerIDManager.GetPlayerID(result);
			}
			return null;
		}

		protected void OnReceivePartner(PlayerID id)
		{
			if (id == null)
			{
				Notifier.Send(new Notification
				{
					Title = "Entangled Partner Assignment",
					Message = "You have no assigned partner! Wait for a new person to join the lobby!",
					SaveToMenu = false,
					ShowPopup = true,
					PopupLength = 5f
				});
				_partner = null;
				EntangledTether tether = GetTether(PlayerIDManager.LocalID);
				if (tether != null)
				{
					tether.Dispose();
					_tethers.RemoveInstance(tether);
				}
			}
			else
			{
				_partner = id;
				_tethers.Add(new EntangledTether(PlayerIDManager.LocalID, id));
				id.TryGetDisplayName(out var name);
				Notifier.Send(new Notification
				{
					Title = "Entangled Partner Assignment",
					Message = "Your partner is: " + name,
					SaveToMenu = false,
					ShowPopup = true,
					PopupLength = 5f
				});
			}
		}

		protected override void OnMetadataChanged(string key, string value)
		{
			if (GetPartnerKey(PlayerIDManager.LocalID) == key)
			{
				ulong result;
				if (value == "-1")
				{
					OnReceivePartner(null);
				}
				else if (ulong.TryParse(value, out result))
				{
					OnReceivePartner(PlayerIDManager.GetPlayerID(result));
				}
			}
			else if (value != "-1" && key.StartsWith("InternalEntangledMetadata.Partner"))
			{
				PlayerID playerId = GetPlayerId(key);
				if (playerId != null && ulong.TryParse(value, out var result2))
				{
					_tethers.Add(new EntangledTether(playerId, PlayerIDManager.GetPlayerID(result2)));
				}
			}
		}

		protected override void OnMetadataRemoved(string key, string value)
		{
			if (GetPartnerKey(PlayerIDManager.LocalID) == key)
			{
				_partner = null;
				EntangledTether tether = GetTether(PlayerIDManager.LocalID);
				if (tether != null)
				{
					tether.Dispose();
					_tethers.RemoveInstance(tether);
				}
			}
			else
			{
				if (!key.StartsWith("InternalEntangledMetadata.Partner"))
				{
					return;
				}
				PlayerID playerId = GetPlayerId(key);
				if (playerId != null)
				{
					EntangledTether tether2 = GetTether(playerId);
					if (tether2 != null)
					{
						tether2.Dispose();
						_tethers.RemoveInstance(tether2);
					}
				}
			}
		}

		protected PlayerID GetPlayerId(string partnerKey)
		{
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				if (GetPartnerKey(playerID) == partnerKey)
				{
					return playerID;
				}
			}
			return null;
		}

		protected EntangledTether GetTether(PlayerID id)
		{
			foreach (EntangledTether tether in _tethers)
			{
				if (tether.player1 == id || tether.player2 == id)
				{
					return tether;
				}
			}
			return null;
		}
	}
	public class HideAndSeek : Gamemode
	{
		public static class Defaults
		{
			public const int SeekerCount = 1;

			public const int SeekerBitReward = 50;

			public const int HiderBitReward = 20;

			public const int TimeLimit = 10;

			public static readonly MonoDiscReference[] Tracks = FusionMonoDiscPlaylists.AmbientPlaylist;
		}

		[CompilerGenerated]
		private sealed class <HideVisionAndReveal>d__67 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private float <notificationWait>5__2;

			private float <fadeLength>5__3;

			private float <elapsed>5__4;

			private float <totalElapsed>5__5;

			private int <seconds>5__6;

			private int <maxSeconds>5__7;

			private bool <secondPassed>5__8;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <HideVisionAndReveal>d__67(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					LocalVision.Blind = true;
					LocalVision.BlindColor = Color.black;
					LocalControls.LockedMovement = true;
					<notificationWait>5__2 = 0f;
					goto IL_006e;
				case 1:
					<>1__state = -1;
					goto IL_006e;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_006e:
					if (<notificationWait>5__2 < 4f)
					{
						<notificationWait>5__2 += TimeReferences.DeltaTime;
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<fadeLength>5__3 = 1f;
					<elapsed>5__4 = 0f;
					<totalElapsed>5__5 = 0f;
					<seconds>5__6 = 0;
					<maxSeconds>5__7 = 30;
					<secondPassed>5__8 = true;
					break;
				}
				if (<seconds>5__6 < <maxSeconds>5__7)
				{
					float num = Mathf.Max((float)<maxSeconds>5__7 - <fadeLength>5__3, 0f);
					float num2 = Mathf.Max(<totalElapsed>5__5 - num, 0f) / <fadeLength>5__3;
					LocalVision.BlindColor = Color.Lerp(Color.black, Color.clear, num2);
					if (<secondPassed>5__8)
					{
						int num3 = <maxSeconds>5__7 - <seconds>5__6;
						switch (num3)
						{
						case 1:
						case 2:
						case 3:
						case 4:
						case 5:
						case 10:
						case 15:
						case 20:
						case 25:
						case 30:
							Notifier.Send(new Notification
							{
								ShowPopup = true,
								Title = "Countdown",
								Message = $"{num3}",
								PopupLength = 1f,
								Type = NotificationType.INFORMATION
							});
							break;
						}
						<secondPassed>5__8 = false;
					}
					<elapsed>5__4 += TimeReferences.DeltaTime;
					<totalElapsed>5__5 += TimeReferences.DeltaTime;
					if (<elapsed>5__4 >= 1f)
					{
						<elapsed>5__4 -= 1f;
						<seconds>5__6++;
						<secondPassed>5__8 = true;
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				LocalControls.LockedMovement = false;
				LocalVision.Blind = false;
				Notifier.Send(new Notification
				{
					ShowPopup = true,
					Title = "Countdown Over",
					Message = "GO!",
					PopupLength = 0.5f,
					Type = NotificationType.INFORMATION
				});
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private readonly MusicPlaylist _playlist = new MusicPlaylist();

		private readonly TeamManager _teamManager = new TeamManager();

		private readonly Team _seekerTeam = new Team("Seekers");

		private readonly Team _hiderTeam = new Team("Hiders");

		private bool _hasBeenTagged;

		private bool _assignedDefaultTeam;

		private readonly HashSet<ulong> _tagRewards = new HashSet<ulong>();

		private float _elapsedTime;

		private bool _oneMinuteLeft;

		private int _lastCheckedMinutes;

		public override string Title => "Hide And Seek";

		public override string Author => "Lakatrazz";

		public override string Description => "Seekers are picked at random, while the rest of the players must hide! After a 30 second countdown, the seekers must grab other players to turn them into seekers! Once everyone becomes a seeker, the seekers win; however, if the time runs out before then, the hiders win!";

		public override Texture Logo => MenuResources.GetGamemodeIcon(Title);

		public int TimeLimit { get; set; } = 10;


		public int SeekerCount { get; set; } = 1;


		public MusicPlaylist Playlist => _playlist;

		public TeamManager TeamManager => _teamManager;

		public Team SeekerTeam => _seekerTeam;

		public Team HiderTeam => _hiderTeam;

		public TriggerEvent TagEvent { get; set; }

		public TriggerEvent OneMinuteLeftEvent { get; set; }

		public TriggerEvent SeekerVictoryEvent { get; set; }

		public TriggerEvent HiderVictoryEvent { get; set; }

		public float ElapsedSeconds => _elapsedTime;

		public int ElapsedMinutes => Mathf.FloorToInt(ElapsedSeconds / 60f);

		public override bool DisableDevTools => true;

		public override bool DisableSpawnGun => true;

		public override GroupElementData CreateSettingsGroup()
		{
			GroupElementData groupElementData = base.CreateSettingsGroup();
			GroupElementData groupElementData2 = new GroupElementData("General");
			groupElementData.AddElement(groupElementData2);
			IntElementData element = new IntElementData
			{
				Title = "Seeker Count",
				Value = SeekerCount,
				Increment = 1,
				MinValue = 1,
				MaxValue = 8,
				OnValueChanged = delegate(int v)
				{
					SeekerCount = v;
				}
			};
			groupElementData2.AddElement(element);
			IntElementData element2 = new IntElementData
			{
				Title = "Time Limit",
				Value = TimeLimit,
				Increment = 1,
				MinValue = 1,
				MaxValue = 60,
				OnValueChanged = delegate(int v)
				{
					TimeLimit = v;
				}
			};
			groupElementData2.AddElement(element2);
			return groupElementData;
		}

		public override void OnGamemodeRegistered()
		{
			FusionOverrides.OnValidateNametag += OnValidateNametag;
			TeamManager.Register(this);
			TeamManager.AddTeam(SeekerTeam);
			TeamManager.AddTeam(HiderTeam);
			TeamManager.OnAssignedToTeam += OnAssignedToTeam;
			TagEvent = new TriggerEvent("TagPlayer", base.Relay);
			TagEvent.OnTriggeredWithValue += OnTagTriggered;
			OneMinuteLeftEvent = new TriggerEvent("OneMinuteLeft", base.Relay, serverOnly: true);
			OneMinuteLeftEvent.OnTriggered += OnOneMinuteLeft;
			SeekerVictoryEvent = new TriggerEvent("SeekerVictory", base.Relay, serverOnly: true);
			SeekerVictoryEvent.OnTriggered += OnSeekerVictory;
			HiderVictoryEvent = new TriggerEvent("HiderVictory", base.Relay, serverOnly: true);
			HiderVictoryEvent.OnTriggered += OnHiderVictory;
		}

		public override void OnGamemodeUnregistered()
		{
			FusionOverrides.OnValidateNametag -= OnValidateNametag;
			TeamManager.Unregister();
			TeamManager.OnAssignedToTeam -= OnAssignedToTeam;
			TagEvent.UnregisterEvent();
			TagEvent = null;
			OneMinuteLeftEvent.UnregisterEvent();
			OneMinuteLeftEvent = null;
			SeekerVictoryEvent.UnregisterEvent();
			SeekerVictoryEvent = null;
			HiderVictoryEvent.UnregisterEvent();
			HiderVictoryEvent = null;
		}

		protected bool OnValidateNametag(PlayerID id)
		{
			if (!base.IsStarted)
			{
				return true;
			}
			return TeamManager.IsTeammate(id);
		}

		private void OnTagTriggered(string value)
		{
			if (!ulong.TryParse(value, out var result))
			{
				FusionLogger.Warn("Player Tag was triggered, but the value " + value + " is not a userId!");
				return;
			}
			PlayerID playerID = PlayerIDManager.GetPlayerID(result);
			if (playerID == null)
			{
				return;
			}
			if (NetworkInfo.IsHost && HiderTeam.HasPlayer(playerID))
			{
				if (HiderTeam.PlayerCount <= 1)
				{
					SeekerVictoryEvent.TryInvoke();
					GamemodeManager.StopGamemode();
				}
				else
				{
					TeamManager.TryAssignTeam(playerID, SeekerTeam);
				}
			}
			if (playerID.IsMe && !_hasBeenTagged)
			{
				Notifier.Send(new Notification
				{
					ShowPopup = true,
					Title = "Tagged",
					Message = "You've been tagged! You are now a seeker!",
					PopupLength = 4f,
					Type = NotificationType.INFORMATION
				});
				_hasBeenTagged = true;
			}
			if (!playerID.IsMe)
			{
				playerID.TryGetDisplayName(out var name);
				Notifier.Send(new Notification
				{
					ShowPopup = true,
					Title = name + " Tagged",
					Message = name + " has been tagged and is now a seeker!",
					PopupLength = 4f,
					Type = NotificationType.INFORMATION
				});
				if (_tagRewards.Remove(playerID.PlatformID))
				{
					PointItemManager.RewardBits(50);
				}
			}
		}

		private void OnOneMinuteLeft()
		{
			Notifier.Send(new Notification
			{
				Title = "Hide And Seek Timer",
				Message = "One minute left!",
				SaveToMenu = false,
				ShowPopup = true
			});
		}

		private void OnSeekerVictory()
		{
			Notifier.Send(new Notification
			{
				ShowPopup = true,
				Title = "Seekers Won",
				Message = "All hiders have been found!",
				PopupLength = 4f,
				Type = NotificationType.INFORMATION
			});
		}

		private void OnHiderVictory()
		{
			Notifier.Send(new Notification
			{
				ShowPopup = true,
				Title = "Hiders Won",
				Message = "The hiders weren't found in time!",
				PopupLength = 4f,
				Type = NotificationType.INFORMATION
			});
			if (TeamManager.GetLocalTeam() == HiderTeam)
			{
				int playerCount = SeekerTeam.PlayerCount;
				PointItemManager.RewardBits(20 * playerCount);
			}
		}

		private void OnAssignedToTeam(PlayerID player, Team team)
		{
			FusionOverrides.ForceUpdateOverrides();
			if (player.IsMe && !_assignedDefaultTeam)
			{
				if (team == HiderTeam)
				{
					Notifier.Send(new Notification
					{
						ShowPopup = true,
						Title = "Hider",
						Message = "You are a hider! Don't let the seekers grab you!",
						PopupLength = 4f,
						Type = NotificationType.INFORMATION
					});
				}
				if (team == SeekerTeam)
				{
					Notifier.Send(new Notification
					{
						ShowPopup = true,
						Title = "Seeker",
						Message = "You are a seeker! Grab all hiders to win!",
						PopupLength = 2f,
						Type = NotificationType.INFORMATION
					});
					MelonCoroutines.Start(HideVisionAndReveal());
				}
				_assignedDefaultTeam = true;
			}
		}

		private static void TeleportToHost()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkInfo.IsHost && NetworkPlayerManager.TryGetPlayer(PlayerIDManager.GetHostID().SmallID, out var player) && player.HasRig)
			{
				LocalPlayer.TeleportToPosition(player.RigRefs.RigManager.physicsRig.feet.transform.position, Vector3.forward);
			}
		}

		[IteratorStateMachine(typeof(<HideVisionAndReveal>d__67))]
		private static IEnumerator HideVisionAndReveal()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HideVisionAndReveal>d__67(0);
		}

		private void SetDefaults()
		{
			Playlist.SetPlaylist(AudioReference.CreateReferences(Defaults.Tracks));
			Playlist.Shuffle();
		}

		public override void OnGamemodeStarted()
		{
			base.OnGamemodeStarted();
			_tagRewards.Clear();
			_hasBeenTagged = false;
			SetDefaults();
			Playlist.StartPlaylist();
			LocalPlayer.OnGrab = (PlayerGrabDelegate)Delegate.Combine(LocalPlayer.OnGrab, new PlayerGrabDelegate(OnLocalPlayerGrab));
			LocalControls.DisableSlowMo = true;
			if (NetworkInfo.IsHost)
			{
				AssignTeams();
			}
			TeleportToHost();
			FusionOverrides.ForceUpdateOverrides();
			_elapsedTime = 0f;
			_lastCheckedMinutes = 0;
			_oneMinuteLeft = false;
		}

		public override void OnGamemodeStopped()
		{
			base.OnGamemodeStopped();
			_hasBeenTagged = false;
			_assignedDefaultTeam = false;
			Playlist.StopPlaylist();
			LocalPlayer.OnGrab = (PlayerGrabDelegate)Delegate.Remove(LocalPlayer.OnGrab, new PlayerGrabDelegate(OnLocalPlayerGrab));
			LocalControls.DisableSlowMo = false;
			if (NetworkInfo.IsHost)
			{
				ClearTeams();
			}
			FusionOverrides.ForceUpdateOverrides();
			_elapsedTime = 0f;
			_lastCheckedMinutes = 0;
			_oneMinuteLeft = false;
		}

		protected override void OnUpdate()
		{
			if (base.IsStarted)
			{
				_elapsedTime += TimeReferences.DeltaTime;
				Playlist.Update();
				if (TeamManager.GetLocalTeam() == HiderTeam)
				{
					OnHiderUpdate();
				}
				if (NetworkInfo.IsHost && !_oneMinuteLeft && TimeLimit - ElapsedMinutes == 1)
				{
					OneMinuteLeftEvent.TryInvoke();
					_oneMinuteLeft = true;
				}
				if (ElapsedMinutes >= TimeLimit)
				{
					HiderVictoryEvent?.TryInvoke();
					GamemodeManager.StopGamemode();
				}
			}
		}

		private void OnHiderUpdate()
		{
			if (_lastCheckedMinutes != ElapsedMinutes)
			{
				_lastCheckedMinutes = ElapsedMinutes;
				PointItemManager.RewardBits(20);
			}
		}

		private void AssignTeams()
		{
			List<PlayerID> list = new List<PlayerID>(PlayerIDManager.PlayerIDs);
			list.Shuffle();
			for (int i = 0; i < SeekerCount && i < list.Count; i++)
			{
				PlayerID playerID = list[i];
				TeamManager.TryAssignTeam(playerID, SeekerTeam);
				list.Remove(playerID);
			}
			foreach (PlayerID item in list)
			{
				TeamManager.TryAssignTeam(item, HiderTeam);
			}
		}

		private void ClearTeams()
		{
			TeamManager.UnassignAllPlayers();
		}

		private void OnLocalPlayerGrab(Hand hand, Grip grip)
		{
			if (SeekerTeam.HasPlayer(PlayerIDManager.LocalID) && Object.op_Implicit((Object)(object)grip._marrowEntity) && NetworkPlayerManager.TryGetPlayer(grip._marrowEntity, out var player) && HiderTeam.HasPlayer(player.PlayerID))
			{
				ulong platformID = player.PlayerID.PlatformID;
				_tagRewards.Add(platformID);
				TagEvent.TryInvoke(platformID.ToString());
			}
		}
	}
	public class Juggernaut : Gamemode
	{
		public static class Defaults
		{
			public const float SurvivorVitality = 1f;

			public const float JuggernautVitality = 10f;

			public const float SurvivorHeight = 1.76f;

			public const float JuggernautHeight = 2.2879999f;

			public const int MaxPoints = 20;

			public const int MaxBits = 1000;
		}

		private readonly TeamManager _teamManager = new TeamManager();

		private readonly Team _survivorTeam = new Team("Survivors");

		private readonly Team _juggernautTeam = new Team("Juggernaut");

		private readonly PlayerScoreKeeper _juggernautScoreKeeper = new PlayerScoreKeeper();

		private readonly MusicPlaylist _playlist = new MusicPlaylist();

		private MonoDiscReference _victorySongReference;

		private MonoDiscReference _failureSongReference;

		private int _minimumPlayers = 2;

		public override string Title => "Juggernaut";

		public override string Author => "Lakatrazz";

		public override string Description => "One player becomes the Juggernaut, a massive beast with copious amounts of health! Defeat the Juggernaut to gain their power, and kill the remaining survivors! First Juggernaut to reach 20 kills wins. More Bits are given for each kill.";

		public override Texture Logo => MenuResources.GetGamemodeIcon(Title);

		public override bool AutoHolsterOnDeath => true;

		public override bool DisableDevTools => true;

		public override bool DisableSpawnGun => true;

		public override bool DisableManualUnragdoll => true;

		public TeamManager TeamManager => _teamManager;

		public Team SurvivorTeam => _survivorTeam;

		public Team JuggernautTeam => _juggernautTeam;

		public PlayerScoreKeeper JuggernautScoreKeeper => _juggernautScoreKeeper;

		public MusicPlaylist Playlist => _playlist;

		public int MinimumPlayers
		{
			get
			{
				return _minimumPlayers;
			}
			set
			{
				_minimumPlayers = value;
				if (!base.IsStarted && base.IsSelected)
				{
					GamemodeManager.ValidateReadyConditions();
				}
			}
		}

		public override void OnGamemodeRegistered()
		{
			TeamManager.Register(this);
			TeamManager.AddTeam(SurvivorTeam);
			TeamManager.AddTeam(JuggernautTeam);
			TeamManager.OnAssignedToTeam += OnAssignedToTeam;
			TeamManager.OnRemovedFromTeam += OnRemovedFromTeam;
			MultiplayerHooking.OnPlayerAction += OnPlayerAction;
			MultiplayerHooking.OnPlayerJoined += OnPlayerJoin;
			MultiplayerHooking.OnPlayerLeft += OnPlayerLeave;
			JuggernautScoreKeeper.Register(base.Metadata);
			JuggernautScoreKeeper.OnPlayerScoreChanged += OnScoreChanged;
		}

		public override void OnGamemodeUnregistered()
		{
			TeamManager.Unregister();
			TeamManager.OnAssignedToTeam -= OnAssignedToTeam;
			TeamManager.OnRemovedFromTeam -= OnRemovedFromTeam;
			MultiplayerHooking.OnPlayerAction -= OnPlayerAction;
			MultiplayerHooking.OnPlayerJoined -= OnPlayerJoin;
			MultiplayerHooking.OnPlayerLeft -= OnPlayerLeave;
			JuggernautScoreKeeper.Unregister();
			JuggernautScoreKeeper.OnPlayerScoreChanged -= OnScoreChanged;
		}

		public override void OnGamemodeStarted()
		{
			if (NetworkInfo.IsHost)
			{
				JuggernautScoreKeeper.ResetScores();
				AssignTeams();
			}
			LocalHealth.MortalityOverride = true;
			LocalControls.DisableSlowMo = true;
		}

		public override void OnLevelReady()
		{
			ApplyGamemodeSettings();
			Playlist.StartPlaylist();
			GamemodeHelper.SetSpawnPoints(GamemodeMarker.FilterMarkers());
			GamemodeHelper.TeleportToSpawnPoint();
			LocalInventory.SetAmmo(10000);
		}

		public override void OnGamemodeStopped()
		{
			Playlist.StopPlaylist();
			CheckFinalScore();
			if (NetworkInfo.IsHost)
			{
				ClearTeams();
			}
			LocalAvatar.HeightOverride = null;
			LocalHealth.MortalityOverride = null;
			LocalHealth.RegenerationOverride = null;
			LocalHealth.VitalityOverride = null;
			LocalControls.DisableSlowMo = false;
			GamemodeHelper.ResetSpawnPoints();
		}

		public override GroupElementData CreateSettingsGroup()
		{
			GroupElementData groupElementData = base.CreateSettingsGroup();
			GroupElementData groupElementData2 = new GroupElementData("General");
			groupElementData.AddElement(groupElementData2);
			IntElementData element = new IntElementData
			{
				Title = "Minimum Players",
				Value = MinimumPlayers,
				Increment = 1,
				MinValue = 1,
				MaxValue = 255,
				OnValueChanged = delegate(int v)
				{
					MinimumPlayers = v;
				}
			};
			groupElementData2.AddElement(element);
			return groupElementData;
		}

		public override bool CheckReadyConditions()
		{
			return PlayerIDManager.PlayerCount >= MinimumPlayers;
		}

		protected override void OnUpdate()
		{
			if (base.IsStarted)
			{
				Playlist.Update();
			}
		}

		public override bool CanAttack(PlayerID player)
		{
			if (!base.IsStarted)
			{
				return true;
			}
			return !TeamManager.IsTeammate(player);
		}

		public void ApplyGamemodeSettings()
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			_victorySongReference = FusionMonoDiscReferences.LavaGangVictoryReference;
			_failureSongReference = FusionMonoDiscReferences.LavaGangFailureReference;
			MonoDiscReference[] array = FusionMonoDiscReferences.CombatSongReferences;
			GamemodeMusicSettings instance = GamemodeMusicSettings.Instance;
			if ((Object)(object)instance != (Object)null && instance.SongOverrides.Count > 0)
			{
				array = (MonoDiscReference[])(object)new MonoDiscReference[instance.SongOverrides.Count];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = new MonoDiscReference(instance.SongOverrides[i]);
				}
			}
			if ((Object)(object)instance != (Object)null && !string.IsNullOrWhiteSpace(instance.VictorySongOverride))
			{
				_victorySongReference = new MonoDiscReference(instance.VictorySongOverride);
			}
			if ((Object)(object)instance != (Object)null && !string.IsNullOrWhiteSpace(instance.FailureSongOverride))
			{
				_failureSongReference = new MonoDiscReference(instance.FailureSongOverride);
			}
			AudioReference[] playlist = AudioReference.CreateReferences(array);
			Playlist.SetPlaylist(playlist);
			Playlist.Shuffle();
		}

		private void OnPlayerAction(PlayerID player, PlayerActionType type, PlayerID otherPlayer = null)
		{
			if (!base.IsStarted || !NetworkInfo.IsHost || type != PlayerActionType.DYING_BY_OTHER_PLAYER)
			{
				return;
			}
			bool num = player == otherPlayer;
			bool flag = TeamManager.GetPlayerTeam(player) == JuggernautTeam;
			bool flag2 = TeamManager.GetPlayerTeam(otherPlayer) == JuggernautTeam;
			if (num)
			{
				if (flag && PlayerIDManager.HasOtherPlayers)
				{
					IEnumerable<PlayerID> enumerable = PlayerIDManager.PlayerIDs.Where((PlayerID id) => id.SmallID != player.SmallID);
					SwapJuggernaut(enumerable.GetRandom(), player);
				}
				return;
			}
			if (flag)
			{
				SwapJuggernaut(otherPlayer, player);
			}
			if (flag2)
			{
				int num2 = JuggernautScoreKeeper.GetScore(otherPlayer) + 1;
				JuggernautScoreKeeper.SetScore(otherPlayer, num2);
				if (num2 >= 20)
				{
					GamemodeManager.StopGamemode();
				}
			}
		}

		private void OnPlayerJoin(PlayerID playerId)
		{
			if (base.IsStarted && NetworkInfo.IsHost)
			{
				TeamManager.TryAssignTeam(playerId, SurvivorTeam);
			}
		}

		private void OnPlayerLeave(PlayerID playerId)
		{
			if (base.IsStarted && NetworkInfo.IsHost)
			{
				if (TeamManager.GetPlayerTeam(playerId) == JuggernautTeam)
				{
					TeamManager.TryAssignTeam(PlayerIDManager.PlayerIDs.GetRandom(), JuggernautTeam);
				}
				TeamManager.TryUnassignTeam(playerId);
			}
		}

		private void CheckFinalScore()
		{
			PlayerID playerByPlace = JuggernautScoreKeeper.GetPlayerByPlace(0);
			PlayerID playerByPlace2 = JuggernautScoreKeeper.GetPlayerByPlace(1);
			PlayerID playerByPlace3 = JuggernautScoreKeeper.GetPlayerByPlace(2);
			int num = JuggernautScoreKeeper.GetPlace(PlayerIDManager.LocalID) + 1;
			int score = JuggernautScoreKeeper.GetScore(PlayerIDManager.LocalID);
			string text = "No one scored points!";
			if (playerByPlace != null && playerByPlace.TryGetDisplayName(out var name))
			{
				text = $"First Place: {name} (Score: {JuggernautScoreKeeper.GetScore(playerByPlace)}) \n";
			}
			if (playerByPlace2 != null && playerByPlace2.TryGetDisplayName(out name))
			{
				text += $"Second Place: {name} (Score: {JuggernautScoreKeeper.GetScore(playerByPlace2)}) \n";
			}
			if (playerByPlace3 != null && playerByPlace3.TryGetDisplayName(out name))
			{
				text += $"Third Place: {name} (Score: {JuggernautScoreKeeper.GetScore(playerByPlace3)}) \n";
			}
			if (num != -1 && num > 3)
			{
				text += $"Your Place: {num} (Score: {score})";
			}
			if (PlayerIDManager.PlayerCount > 1)
			{
				bool isVictory = num <= 1;
				OnVictoryStatus(isVictory);
			}
			Notifier.Send(new Notification
			{
				Title = "Juggernaut Completed",
				Message = text,
				PopupLength = 6f,
				SaveToMenu = false,
				ShowPopup = true
			});
			int num2 = CalculateBitReward(score);
			if (num2 > 0)
			{
				PointItemManager.RewardBits(num2);
			}
		}

		private void OnVictoryStatus(bool isVictory = false)
		{
			MonoDiscReference val = ((!isVictory) ? _failureSongReference : _victorySongReference);
			if (val != null)
			{
				LocalAudioPlayer.Play2dOneShot(new AudioReference(val), LocalAudioPlayer.MusicSettings);
			}
		}

		private void OnScoreChanged(PlayerID player, int score)
		{
			if (score != 0)
			{
				if (TeamManager.GetPlayerTeam(player) != JuggernautTeam)
				{
					FusionLogger.Warn($"Player {player.SmallID} increased in score, but they aren't the Juggernaut?");
				}
				else if (player.IsMe)
				{
					Notifier.Send(new Notification
					{
						ShowPopup = true,
						Title = "Juggernaut Point",
						Message = $"Your Juggernaut score is now {score}!",
						PopupLength = 2f,
						Type = NotificationType.INFORMATION
					});
				}
			}
		}

		private static float CalculateJuggernautHealth()
		{
			int num = Mathf.Max(1, PlayerIDManager.PlayerCount - 1);
			return Mathf.Round(10f * Mathf.Sqrt((float)num) * 0.1f) * 10f;
		}

		private static int CalculateBitReward(int score)
		{
			return Mathf.Clamp(Mathf.RoundToInt(Mathf.Pow((float)score / 20f, 2f) * 1000f), 0, 1000);
		}

		private void OnAssignedToTeam(PlayerID player, Team team)
		{
			if (player.IsMe)
			{
				OnSelfAssignedToTeam(team);
			}
			else
			{
				OnOtherAssignedToTeam(player, team);
			}
		}

		private void OnRemovedFromTeam(PlayerID player, Team team)
		{
			if (team == JuggernautTeam && NetworkPlayerManager.TryGetPlayer((byte)player, out NetworkPlayer player2))
			{
				player2.HealthBar.Visible = false;
			}
		}

		private void OnSelfAssignedToTeam(Team team)
		{
			if (team == SurvivorTeam)
			{
				Notifier.Send(new Notification
				{
					ShowPopup = true,
					Title = "Survivor",
					Message = "You are a survivor! Defeat the Juggernaut to gain its strength!",
					PopupLength = 4f,
					Type = NotificationType.INFORMATION
				});
				LocalHealth.VitalityOverride = 1f;
				LocalHealth.RegenerationOverride = false;
				LocalAvatar.HeightOverride = 1.76f;
			}
			if (team == JuggernautTeam)
			{
				Notifier.Send(new Notification
				{
					ShowPopup = true,
					Title = "Juggernaut",
					Message = "You are the Juggernaut! Keep your position and kill survivors!",
					PopupLength = 4f,
					Type = NotificationType.INFORMATION
				});
				LocalHealth.VitalityOverride = CalculateJuggernautHealth();
				LocalHealth.RegenerationOverride = false;
				LocalHealth.SetFullHealth();
				LocalAvatar.HeightOverride = 2.2879999f;
			}
		}

		private void OnOtherAssignedToTeam(PlayerID player, Team team)
		{
			bool visible = false;
			if (team == JuggernautTeam)
			{
				player.TryGetDisplayName(out var name);
				Notifier.Send(new Notification
				{
					ShowPopup = true,
					Title = "Juggernaut " + name,
					Message = name + " became the Juggernaut!",
					PopupLength = 2f,
					Type = NotificationType.INFORMATION
				});
				visible = true;
			}
			if (NetworkPlayerManager.TryGetPlayer((byte)player, out NetworkPlayer player2))
			{
				player2.HealthBar.Visible = visible;
			}
		}

		private void SwapJuggernaut(PlayerID killer, PlayerID juggernaut)
		{
			TeamManager.TryAssignTeam(killer, JuggernautTeam);
			TeamManager.TryAssignTeam(juggernaut, SurvivorTeam);
		}

		private void AssignTeams()
		{
			List<PlayerID> list = new List<PlayerID>(PlayerIDManager.PlayerIDs);
			list.Shuffle();
			if (list.Count > 0)
			{
				PlayerID playerID = list[0];
				TeamManager.TryAssignTeam(playerID, JuggernautTeam);
				list.Remove(playerID);
			}
			foreach (PlayerID item in list)
			{
				TeamManager.TryAssignTeam(item, SurvivorTeam);
			}
		}

		private void ClearTeams()
		{
			TeamManager.UnassignAllPlayers();
		}
	}
	public class SmashBones : Gamemode
	{
		[Serializable]
		public struct DamageInfo
		{
			[JsonPropertyName("platformID")]
			public ulong PlatformID { get; set; }

			[JsonPropertyName("damage")]
			public float Damage { get; set; }
		}

		[Serializable]
		public struct DeathInfo
		{
			[JsonPropertyName("platformID")]
			public ulong PlatformID { get; set; }

			[JsonPropertyName("position")]
			public JsonVector3 Position { get; set; }

			[JsonPropertyName("direction")]
			public JsonVector3 Direction { get; set; }
		}

		public static class Defaults
		{
			public const float AirControlSpeed = 5f;

			public const float DashCooldown = 0.3f;

			public const float DashSpeed = 10f;

			public const float AirDashSpeed = 6f;

			public const float ExtraJumpVelocity = 8f;

			public const int StockCount = 3;

			public const float ExtraJumpCooldown = 0.2f;

			public const bool DropItems = true;

			public const float ItemFrequency = 10f;

			public const float MaxAvatarHeight = 3f;

			public const float SecondDashHeight = 1.6f;

			public const float SecondJumpHeight = 1.3f;

			public const float WeakJumpHeight = 1.8f;

			public const float WeakestJumpHeight = 3f;

			public const float WeakMobilityMass = 100f;

			public const float WeakestMobilityMass = 250f;

			public const int BitRewardPerPlayer = 100;
		}

		public const string NotificationTag = "SmashBones";

		private int _minimumPlayers = 2;

		private readonly MusicPlaylist _playlist = new MusicPlaylist();

		private readonly PlayerScoreKeeper _playerScoreKeeper = new PlayerScoreKeeper();

		private readonly PlayerScoreKeeper _playerStocksKeeper = new PlayerScoreKeeper();

		private readonly MetadataPlayerDictionary<MetadataFloat> _playerDamageKeeper = new MetadataPlayerDictionary<MetadataFloat>();

		private readonly TeamManager _teamManager = new TeamManager();

		private readonly Team _freeForAllTeam = new Team("Free For All");

		private readonly Team _spectatorTeam = new Team("Spectators");

		private int _previousStocks = -1;

		private int _latestScore;

		private MonoDiscReference _victorySongReference;

		private MonoDiscReference _failureSongReference;

		private static float _itemDropTimer;

		private static int _remainingJumps;

		private static float _airTime;

		private static float _dashCooldown;

		private static int _midAirDashCount;

		public override string Title => "Smash Bones";

		public override string Author => "Lakatrazz";

		public override string Description => "Attack other players to build up damage, and knock them off the map to take their stocks! Use randomly spawned items to gain advantages over your opponents! You are also given <color=#00b3ff>extra abilities</color> such as <color=#00b3ff>Double Jumping</color>, <color=#00b3ff>Dashing</color>, and <color=#00b3ff>Air Control</color>. Last person standing wins. <color=#ff0000>Requires a Smash Bones supported map.</color>";

		public override Texture Logo => MenuResources.GetGamemodeIcon(Title);

		public override bool AutoHolsterOnDeath => true;

		public override bool DisableDevTools => true;

		public override bool DisableSpawnGun => true;

		public override bool DisableManualUnragdoll => true;

		public int MinimumPlayers
		{
			get
			{
				return _minimumPlayers;
			}
			set
			{
				_minimumPlayers = value;
				if (!base.IsStarted && base.IsSelected)
				{
					GamemodeManager.ValidateReadyConditions();
				}
			}
		}

		public MusicPlaylist Playlist => _playlist;

		public PlayerScoreKeeper PlayerScoreKeeper => _playerScoreKeeper;

		public PlayerScoreKeeper PlayerStocksKeeper => _playerStocksKeeper;

		public MetadataPlayerDictionary<MetadataFloat> PlayerDamageKeeper => _playerDamageKeeper;

		public TeamManager TeamManager => _teamManager;

		public Team FreeForAllTeam => _freeForAllTeam;

		public Team SpectatorTeam => _spectatorTeam;

		public TriggerEvent PlayerDamageEvent { get; set; }

		public TriggerEvent PlayerDeathEvent { get; set; }

		public override GroupElementData CreateSettingsGroup()
		{
			GroupElementData groupElementData = base.CreateSettingsGroup();
			GroupElementData groupElementData2 = new GroupElementData("General");
			groupElementData.AddElement(groupElementData2);
			IntElementData element = new IntElementData
			{
				Title = "Minimum Players",
				Value = MinimumPlayers,
				Increment = 1,
				MinValue = 1,
				MaxValue = 255,
				OnValueChanged = delegate(int v)
				{
					MinimumPlayers = v;
				}
			};
			groupElementData2.AddElement(element);
			return groupElementData;
		}

		public override bool CheckReadyConditions()
		{
			return PlayerIDManager.PlayerCount >= MinimumPlayers;
		}

		public override void OnGamemodeRegistered()
		{
			PlayerDamageEvent = new TriggerEvent("PlayerDamage", base.Relay);
			PlayerDamageEvent.OnTriggeredWithValue += OnPlayerDamageEvent;
			PlayerDeathEvent = new TriggerEvent("PlayerDeath", base.Relay);
			PlayerDeathEvent.OnTriggeredWithValue += OnPlayerDeathEvent;
			TeamManager.Register(this);
			TeamManager.AddTeam(FreeForAllTeam);
			TeamManager.AddTeam(SpectatorTeam);
			TeamManager.OnAssignedToTeam += OnAssignedToTeam;
			TeamManager.OnRemovedFromTeam += OnRemovedFromTeam;
			PlayerScoreKeeper.Register(base.Metadata);
			PlayerStocksKeeper.Register(base.Metadata, "Lives");
			PlayerStocksKeeper.OnPlayerScoreChanged += OnLivesChanged;
			PlayerDamageKeeper.Register(base.Metadata, "Damage");
			PlayerDamageKeeper.OnPlayerVariableChanged += OnDamageChanged;
			LocalHealth.OnAttackedByPlayer += OnAttackedByPlayer;
		}

		public override void OnGamemodeUnregistered()
		{
			PlayerDamageEvent.UnregisterEvent();
			TeamManager.Unregister();
			TeamManager.OnAssignedToTeam -= OnAssignedToTeam;
			TeamManager.OnRemovedFromTeam -= OnRemovedFromTeam;
			PlayerScoreKeeper.Unregister();
			PlayerStocksKeeper.Unregister();
			PlayerStocksKeeper.OnPlayerScoreChanged -= OnLivesChanged;
			PlayerDamageKeeper.Unregister();
			PlayerDamageKeeper.OnPlayerVariableChanged -= OnDamageChanged;
			LocalHealth.OnAttackedByPlayer -= OnAttackedByPlayer;
		}

		private void OnAssignedToTeam(PlayerID player, Team team)
		{
			bool flag = team == SpectatorTeam;
			bool flag2 = TeamManager.GetLocalTeam() == SpectatorTeam;
			if (NetworkPlayerManager.TryGetPlayer((byte)player, out NetworkPlayer player2))
			{
				player2.LivesBar.Visible = !flag;
				player2.ForceHide = flag && !flag2;
			}
			if (player.IsMe)
			{
				OnSelfAssignedToTeam(team);
			}
		}

		private void OnRemovedFromTeam(PlayerID player, Team team)
		{
			if (NetworkPlayerManager.TryGetPlayer((byte)player, out NetworkPlayer player2))
			{
				player2.LivesBar.Visible = false;
				player2.ForceHide = false;
			}
		}

		private void OnSelfAssignedToTeam(Team team)
		{
			bool flag2 = (LocalControls.DisableInteraction = team == SpectatorTeam);
			OnSetSpawn(flag2);
			OnCheckPlayerHiding(flag2);
		}

		private void OnCheckPlayerHiding(bool selfSpectator)
		{
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				if (!playerID.IsMe && NetworkPlayerManager.TryGetPlayer((byte)playerID, out NetworkPlayer player))
				{
					bool flag = TeamManager.GetPlayerTeam(playerID) == SpectatorTeam;
					player.ForceHide = flag && !selfSpectator;
				}
			}
		}

		private void OnAttackedByPlayer(Attack attack, BodyPart bodyPart, PlayerID player)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			if (base.IsStarted && TeamManager.GetPlayerTeam(player) != SpectatorTeam && TeamManager.GetLocalTeam() != SpectatorTeam)
			{
				float value = PlayerDamageKeeper.GetVariable(PlayerIDManager.LocalID).GetValue();
				float num = attack.damage;
				if ((int)attack.attackType == 2)
				{
					num *= 5f;
				}
				num = ManagedMathf.Clamp(num, 0f, 12f);
				value += num;
				value = ManagedMathf.Clamp(value, 0f, 999f);
				PlayerDamageEvent.TryInvoke(JsonSerializer.Serialize(new DamageInfo
				{
					PlatformID = PlayerIDManager.LocalPlatformID,
					Damage = value
				}));
				Vector3 val = attack.direction;
				Vector3 normalized = ((Vector3)(ref val)).normalized;
				normalized.y = 0f;
				((Vector3)(ref normalized)).Normalize();
				float num2 = (1f + MathF.Pow(value, 0.8f)) * 3f;
				if (RigData.HasPlayer)
				{
					RigManager rigManager = RigData.Refs.RigManager;
					Rigidbody pelvisRb = rigManager.physicsRig.torso._pelvisRb;
					float massTotal = rigManager.avatar.massTotal;
					num2 *= CalculateMassContribution(massTotal);
					Vector3 val2 = normalized * num2;
					val = Physics.gravity;
					Vector3 val3 = -((Vector3)(ref val)).normalized * num2 * 0.2f;
					Vector3 val4 = val2 + val3;
					pelvisRb.AddForce(val4, (ForceMode)1);
					SlipGrip(rigManager.physicsRig.leftHand);
					SlipGrip(rigManager.physicsRig.rightHand);
				}
			}
		}

		private static float CalculateMassContribution(float avatarMass)
		{
			return MathF.Pow(avatarMass / 80f, 0.8f) * 10f;
		}

		private static void SlipGrip(Hand hand)
		{
			HandReciever attachedReceiver = hand.AttachedReceiver;
			if ((Object)(object)attachedReceiver == (Object)null)
			{
				return;
			}
			Grip val = ((Il2CppObjectBase)attachedReceiver).TryCast<Grip>();
			if (!((Object)(object)val == (Object)null))
			{
				if (((HandReciever)val).IsStatic)
				{
					hand.TryDetach();
				}
				else if (IsPlayerGrip(val))
				{
					RandomDetachHand(hand, 50f);
				}
				else
				{
					RandomDetachHand(hand, 5f);
				}
			}
		}

		private static void RandomDetachHand(Hand hand, float percentChance)
		{
			if (Random.Range(0f, 100f) <= percentChance)
			{
				hand.TryDetach();
			}
		}

		private static bool IsPlayerGrip(Grip grip)
		{
			MarrowEntity marrowEntity = grip._marrowEntity;
			if ((Object)(object)marrowEntity == (Object)null)
			{
				return false;
			}
			if (!IMarrowEntityExtender.Cache.TryGet(marrowEntity, out var value))
			{
				return false;
			}
			return value.GetExtender<NetworkPlayer>() != null;
		}

		private void OnPlayerDamageEvent(string value)
		{
			if (base.IsStarted && NetworkInfo.IsHost)
			{
				DamageInfo damageInfo = JsonSerializer.Deserialize<DamageInfo>(value);
				PlayerID playerID = PlayerIDManager.GetPlayerID(damageInfo.PlatformID);
				PlayerDamageKeeper.GetVariable(playerID).SetValue(damageInfo.Damage);
			}
		}

		private void OnPlayerDeathEvent(string value)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			if (!base.IsStarted)
			{
				return;
			}
			DeathInfo deathInfo = JsonSerializer.Deserialize<DeathInfo>(value);
			PlayerID playerID = PlayerIDManager.GetPlayerID(deathInfo.PlatformID);
			if (NetworkInfo.IsHost)
			{
				int num = PlayerStocksKeeper.GetScore(playerID) - 1;
				if (num < 0)
				{
					num = 0;
				}
				PlayerStocksKeeper.SetScore(playerID, num);
				PlayerDamageKeeper.GetVariable(playerID).SetValue(0f);
				if (num <= 0)
				{
					TeamManager.TryAssignTeam(playerID, SpectatorTeam);
				}
			}
			SpawnExplosion(deathInfo.Position.ToUnityVector3(), -deathInfo.Direction.ToUnityVector3());
			MultiplayerHooking.InvokeOnPlayerAction(playerID, PlayerActionType.DEATH);
		}

		private void OnLivesChanged(PlayerID playerID, int lives)
		{
			if (base.IsStarted)
			{
				if (NetworkPlayerManager.TryGetPlayer((byte)playerID, out NetworkPlayer player))
				{
					player.LivesBar.Lives = lives;
				}
				if (playerID.IsMe)
				{
					OnSelfLivesChanged(lives);
				}
				if (NetworkInfo.IsHost && lives <= 0)
				{
					_latestScore++;
					PlayerScoreKeeper.SetScore(playerID, _latestScore);
					CheckFreeForAllStocksVictory();
				}
			}
		}

		private void CheckFreeForAllStocksVictory()
		{
			List<PlayerID> list = new List<PlayerID>();
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				int score = PlayerStocksKeeper.GetScore(playerID);
				bool flag = SpectatorTeam.HasPlayer(playerID);
				if (score > 0 && !flag)
				{
					list.Add(playerID);
				}
			}
			int num = (PlayerIDManager.HasOtherPlayers ? 1 : 0);
			if (list.Count > num)
			{
				return;
			}
			_latestScore++;
			foreach (PlayerID item in list)
			{
				PlayerScoreKeeper.SetScore(item, _latestScore);
			}
			GamemodeManager.StopGamemode();
		}

		private void OnSelfLivesChanged(int lives)
		{
			if (_previousStocks > lives)
			{
				Notifier.Cancel("SmashBones");
				if (lives > 0)
				{
					Notifier.Send(new Notification
					{
						Title = "Lost a Stock",
						Message = $"You lost a stock! You are now down to {lives} stock{((lives != 1) ? "s" : "")}!",
						Tag = "SmashBones",
						SaveToMenu = false,
						ShowPopup = true,
						PopupLength = 4f,
						Type = NotificationType.INFORMATION
					});
				}
				else
				{
					Notifier.Send(new Notification
					{
						Title = "Lost All Stocks!",
						Message = "You lost all of your stocks! You are now a spectator!",
						Tag = "SmashBones",
						SaveToMenu = false,
						ShowPopup = true,
						PopupLength = 4f,
						Type = NotificationType.INFORMATION
					});
				}
			}
			_previousStocks = lives;
		}

		private void OnDamageChanged(PlayerID player, MetadataFloat damage)
		{
			if (base.IsStarted && NetworkPlayerManager.TryGetPlayer((byte)player, out NetworkPlayer player2))
			{
				player2.LivesBar.Damage = damage.GetValue();
			}
		}

		public override void OnGamemodeStarted()
		{
			LocalHealth.MortalityOverride = false;
			DeathTrigger.KillDamageOverride = false;
			LocalControls.DisableSlowMo = true;
			LocalControls.DisableAmmoPouch = true;
			LocalControls.DisableInventory = true;
			LocalAvatar.HeightOverride = ManagedMathf.Clamp(LocalAvatar.AvatarHeight, 0f, 3f);
			LocalAvatar.AvatarOverride = LocalAvatar.AvatarBarcode;
			DeathTrigger.OnKillPlayer += OnKillPlayer;
			if (NetworkInfo.IsHost)
			{
				PlayerScoreKeeper.ResetScores();
				_latestScore = 0;
				AssignTeams();
			}
			Notifier.Cancel("SmashBones");
			Notifier.Send(new Notification
			{
				Title = "Stock Smash",
				Message = $"All players have {3} stocks! Knock players off the map to deplete their stocks and be the last one standing!",
				Tag = "SmashBones",
				ShowPopup = true,
				SaveToMenu = false,
				PopupLength = 4f,
				Type = NotificationType.INFORMATION
			});
		}

		public override void OnLevelReady()
		{
			ApplyGamemodeSettings();
			Playlist.StartPlaylist();
			OnSetSpawn(SpectatorTeam.HasPlayer(PlayerIDManager.LocalID));
		}

		protected override void OnPlayerJoined(PlayerID playerID)
		{
			if (NetworkInfo.IsHost)
			{
				PlayerStocksKeeper.SetScore(playerID, 0);
				PlayerScoreKeeper.SetScore(playerID, 0);
				PlayerDamageKeeper.GetVariable(playerID).SetValue(0f);
				TeamManager.TryAssignTeam(playerID, SpectatorTeam);
			}
		}

		protected override void OnPlayerLeft(PlayerID playerID)
		{
			if (NetworkInfo.IsHost)
			{
				CheckFreeForAllStocksVictory();
			}
		}

		public override void OnGamemodeStopped()
		{
			Playlist.StopPlaylist();
			LocalHealth.MortalityOverride = null;
			DeathTrigger.KillDamageOverride = null;
			LocalControls.DisableInteraction = false;
			LocalControls.DisableSlowMo = false;
			LocalControls.DisableAmmoPouch = false;
			LocalControls.DisableInventory = false;
			LocalAvatar.HeightOverride = null;
			LocalAvatar.AvatarOverride = null;
			DeathTrigger.OnKillPlayer -= OnKillPlayer;
			GamemodeHelper.ResetSpawnPoints();
			GamemodeHelper.TeleportToSpawnPoint();
			TeamManager.UnassignAllPlayers();
			_previousStocks = -1;
			CheckFinalScore();
			if (NetworkInfo.IsHost)
			{
				GamemodeDropper.DespawnItems();
			}
		}

		private void CheckFinalScore()
		{
			PlayerID playerByPlace = PlayerScoreKeeper.GetPlayerByPlace(0);
			PlayerID playerByPlace2 = PlayerScoreKeeper.GetPlayerByPlace(1);
			PlayerID playerByPlace3 = PlayerScoreKeeper.GetPlayerByPlace(2);
			int num = PlayerScoreKeeper.GetPlace(PlayerIDManager.LocalID) + 1;
			string text = "No one ran out of stocks!";
			if (playerByPlace != null && playerByPlace.TryGetDisplayName(out var name))
			{
				text = "First Place: " + name + " \n";
			}
			if (playerByPlace2 != null && playerByPlace2.TryGetDisplayName(out name))
			{
				text = text + "Second Place: " + name + " \n";
			}
			if (playerByPlace3 != null && playerByPlace3.TryGetDisplayName(out name))
			{
				text = text + "Third Place: " + name + " \n";
			}
			if (num != -1 && num > 3)
			{
				text += $"Your Place: {num}";
			}
			int playerCount = PlayerIDManager.PlayerCount;
			if (playerCount > 1)
			{
				bool isVictory = num <= 1;
				OnVictoryStatus(isVictory);
			}
			Notifier.Cancel("SmashBones");
			Notifier.Send(new Notification
			{
				Title = "Smash Bones Completed",
				Tag = "SmashBones",
				Message = text,
				PopupLength = 6f,
				SaveToMenu = false,
				ShowPopup = true
			});
			RewardBits(num, playerCount);
		}

		private static void RewardBits(int placement, int playerCount)
		{
			if (playerCount > 1 && placement <= 3)
			{
				PointItemManager.RewardBits(100 * playerCount / placement);
			}
		}

		private static void OnSetSpawn(bool spectator)
		{
			if (RigData.HasPlayer)
			{
				if (spectator)
				{
					GamemodeHelper.SetSpawnPoints(GamemodeMarker.FilterMarkers(FusionBoneTagReferences.SpectatorReference));
				}
				else
				{
					GamemodeHelper.SetSpawnPoints(GamemodeMarker.FilterMarkers());
				}
				GamemodeHelper.TeleportToSpawnPoint();
			}
		}

		private void OnKillPlayer()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			Rigidbody pelvisRb = RigData.Refs.RigManager.physicsRig.torso._pelvisRb;
			TriggerEvent playerDeathEvent = PlayerDeathEvent;
			DeathInfo value = new DeathInfo
			{
				PlatformID = PlayerIDManager.LocalPlatformID,
				Position = new JsonVector3(pelvisRb.position)
			};
			Vector3 velocity = pelvisRb.velocity;
			value.Direction = new JsonVector3(((Vector3)(ref velocity)).normalized);
			playerDeathEvent.TryInvoke(JsonSerializer.Serialize(value));
			GamemodeHelper.TeleportToSpawnPoint();
		}

		private static void SpawnExplosion(Vector3 position, Vector3 forward)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.DeathExplosionReference);
			LocalAssetSpawner.Register(spawnable);
			LocalAssetSpawner.Spawn(spawnable, position, Quaternion.LookRotation(forward));
			LocalAudioPlayer.PlayAtPoint(new AudioReference(FusionMonoDiscReferences.DeathExplosionReference), position, new AudioPlayerSettings
			{
				Mixer = LocalAudioPlayer.HardInteraction,
				MinDistance = 50f
			});
		}

		private void AssignTeams()
		{
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				SetupPlayer(playerID);
			}
		}

		private void SetupPlayer(PlayerID player)
		{
			TeamManager.TryAssignTeam(player, FreeForAllTeam);
			PlayerDamageKeeper.GetVariable(player).SetValue(0f);
			PlayerStocksKeeper.SetScore(player, 3);
		}

		protected override void OnUpdate()
		{
			if (base.IsStarted)
			{
				Playlist.Update();
				if (RigData.HasPlayer)
				{
					RigManager rigManager = RigData.Refs.RigManager;
					ApplyDashing(rigManager);
					ApplyAutoRun(rigManager);
					ApplyDoubleJump(rigManager);
				}
				if (NetworkInfo.IsHost)
				{
					UpdateItemDroppers();
				}
			}
		}

		protected override void OnFixedUpdate()
		{
			if (base.IsStarted && RigData.HasPlayer)
			{
				ApplyAirControl(RigData.Refs.RigManager);
			}
		}

		private static void UpdateItemDroppers()
		{
			_itemDropTimer += TimeReferences.DeltaTime;
			if (!(_itemDropTimer < 10f))
			{
				_itemDropTimer = 0f;
				if (GamemodeDropper.DroppedItemCount < GamemodeDropperSettings.GetMaxItems())
				{
					GamemodeDropper.DropItem();
				}
			}
		}

		private static void ApplyAutoRun(RigManager rigManager)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			RemapRig remapHeptaRig = rigManager.remapHeptaRig;
			if ((int)remapHeptaRig.travState == 0)
			{
				remapHeptaRig.travState = (TraversalState)1;
			}
		}

		private static void ApplyAirControl(RigManager rigManager)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			PhysicsRig physicsRig = rigManager.physicsRig;
			if (physicsRig.ballLocoEnabled && !physicsRig.physG.isGrounded)
			{
				float num = CalculateMobilityMultiplier(LocalAvatar.AvatarMass);
				ControllerRig controllerRig = rigManager.ControllerRig;
				Vector2 primaryAxis = controllerRig.GetPrimaryAxis();
				Vector3 val = ((Rig)controllerRig).m_head.rotation * new Vector3(primaryAxis.x, 0f, primaryAxis.y);
				val.y = 0f;
				((Vector3)(ref val)).Normalize();
				Rigidbody rbKnee = physicsRig.rbKnee;
				Vector3 val2 = val * 5f;
				val2.y = 0f;
				Vector3 velocity = rbKnee.velocity;
				velocity.y = 0f;
				Vector3 val3 = (Vector3.ClampMagnitude(velocity, 5f) - velocity) * 5f;
				rbKnee.AddForce((val3 + val2) * rigManager.avatar.massTotal * num, (ForceMode)0);
			}
		}

		private static void ApplyDoubleJump(RigManager rigManager)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			int num = 1;
			float num2 = CalculateJumpMultiplier(LocalAvatar.AvatarHeight);
			if (LocalAvatar.AvatarHeight <= 1.3f)
			{
				num++;
				num2 *= 0.7f;
			}
			PhysicsRig physicsRig = rigManager.physicsRig;
			if (!physicsRig.ballLocoEnabled)
			{
				return;
			}
			if (physicsRig.physG.isGrounded)
			{
				_remainingJumps = num;
				_airTime = 0f;
				return;
			}
			_airTime += TimeReferences.DeltaTime;
			if (!(_airTime <= 0.2f) && _remainingJumps > 0 && rigManager.ControllerRig._secondaryAButtonUp)
			{
				_remainingJumps--;
				_airTime = 0f;
				Vector3 velocity = physicsRig.torso.rbPelvis.velocity;
				velocity.y = 8f * num2;
				SetPhysicsRigVelocity(physicsRig, velocity);
				physicsRig.headSfx.JumpEffort();
			}
		}

		private static void ApplyDashing(RigManager rigManager)
		{
			int num = 1;
			float speedMultiplier = CalculateMobilityMultiplier(LocalAvatar.AvatarMass);
			if (LocalAvatar.AvatarHeight <= 1.6f)
			{
				num++;
			}
			if (_dashCooldown > 0f)
			{
				_dashCooldown -= TimeReferences.DeltaTime;
				return;
			}
			PhysicsRig physicsRig = rigManager.physicsRig;
			if (!physicsRig.ballLocoEnabled)
			{
				return;
			}
			bool isGrounded = physicsRig.physG.isGrounded;
			if (isGrounded || _midAirDashCount < num)
			{
				if (isGrounded)
				{
					_midAirDashCount = 0;
				}
				OpenControllerRig val = ((Il2CppObjectBase)rigManager.ControllerRig).TryCast<OpenControllerRig>();
				if (((ControllerRig)val)._primaryStickDown)
				{
					Dash(val, physicsRig, speedMultiplier);
				}
			}
		}

		private static void Dash(OpenControllerRig controllerRig, PhysicsRig physicsRig, float speedMultiplier = 1f)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			_dashCooldown = 0.3f;
			float num = 10f;
			if (!physicsRig.physG.isGrounded)
			{
				_midAirDashCount++;
				num = 6f;
			}
			num *= speedMultiplier;
			Vector2 primaryAxis = ((ControllerRig)controllerRig).GetPrimaryAxis();
			Vector3 val = ((Rig)controllerRig).m_head.rotation * new Vector3(primaryAxis.x, 0f, primaryAxis.y);
			val.y = 0f;
			((Vector3)(ref val)).Normalize();
			Vector3 velocity = physicsRig.torso.rbPelvis.velocity;
			Vector3 velocity2 = val * num;
			velocity2.y = velocity.y;
			SetPhysicsRigVelocity(physicsRig, velocity2);
		}

		private static float CalculateJumpMultiplier(float avatarHeight)
		{
			float result = 1f;
			if (avatarHeight >= 1.8f)
			{
				float num = ManagedMathf.Clamp01((avatarHeight - 1.8f) / 1.2f) * 0.4f;
				result = 1f - num;
			}
			return result;
		}

		private static float CalculateMobilityMultiplier(float avatarMass)
		{
			float result = 1f;
			if (avatarMass >= 100f)
			{
				float num = ManagedMathf.Clamp01((avatarMass - 100f) / 150f) * 0.8f;
				result = 1f - num;
			}
			return result;
		}

		private static void SetPhysicsRigVelocity(PhysicsRig physicsRig, Vector3 velocity)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			Vector3 velocity2 = physicsRig.torso.rbPelvis.velocity;
			Enumerator<Rigidbody> enumerator = physicsRig.selfRbs.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Rigidbody current = enumerator.Current;
				if (!((Object)(object)current == (Object)null))
				{
					current.velocity = current.velocity - velocity2 + velocity;
				}
			}
		}

		public void ApplyGamemodeSettings()
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			_victorySongReference = FusionMonoDiscReferences.LavaGangVictoryReference;
			_failureSongReference = FusionMonoDiscReferences.LavaGangFailureReference;
			MonoDiscReference[] array = FusionMonoDiscReferences.CombatSongReferences;
			GamemodeMusicSettings instance = GamemodeMusicSettings.Instance;
			if ((Object)(object)instance != (Object)null && instance.SongOverrides.Count > 0)
			{
				array = (MonoDiscReference[])(object)new MonoDiscReference[instance.SongOverrides.Count];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = new MonoDiscReference(instance.SongOverrides[i]);
				}
			}
			if ((Object)(object)instance != (Object)null && !string.IsNullOrWhiteSpace(instance.VictorySongOverride))
			{
				_victorySongReference = new MonoDiscReference(instance.VictorySongOverride);
			}
			if ((Object)(object)instance != (Object)null && !string.IsNullOrWhiteSpace(instance.FailureSongOverride))
			{
				_failureSongReference = new MonoDiscReference(instance.FailureSongOverride);
			}
			AudioReference[] playlist = AudioReference.CreateReferences(array);
			Playlist.SetPlaylist(playlist);
			Playlist.Shuffle();
		}

		private void OnVictoryStatus(bool isVictory = false)
		{
			MonoDiscReference val = ((!isVictory) ? _failureSongReference : _victorySongReference);
			if (val != null)
			{
				LocalAudioPlayer.Play2dOneShot(new AudioReference(val), LocalAudioPlayer.MusicSettings);
			}
		}
	}
	public class TeamDeathmatch : Gamemode
	{
		public const string DefaultSabrelakeName = "Sabrelake";

		public const string DefaultLavaGangName = "Lava Gang";

		private const int _minPlayerBits = 80;

		private const int _maxPlayerBits = 800;

		private const int _defaultMinutes = 3;

		private const int _minMinutes = 2;

		private const int _maxMinutes = 60;

		private float _timeOfStart;

		private bool _oneMinuteLeft;

		private int _savedMinutes = 3;

		private int _totalMinutes = 3;

		private float _savedVitality = 1f;

		private int _minimumPlayers = 4;

		private readonly TeamManager _teamManager = new TeamManager();

		private readonly Team _sabrelakeTeam = new Team("Sabrelake");

		private readonly Team _lavaGangTeam = new Team("Lava Gang");

		private TeamScoreKeeper _scoreKeeper;

		private readonly TeamMusicManager _teamMusicManager = new TeamMusicManager();

		private readonly MusicPlaylist _musicPlaylist = new MusicPlaylist();

		private readonly TeamLogoManager _teamLogoManager = new TeamLogoManager();

		private string _avatarOverride;

		public static TeamDeathmatch Instance { get; private set; }

		public override string Title => "Team Deathmatch";

		public override string Author => "Lakatrazz";

		public override string Description => "Players are randomly selected to be placed in two separate teams. Kill players on the opposite team to gain points before the timer runs out! More Bits are given based on the amount of points your team gains compared to the other team.";

		public override Texture Logo => MenuResources.GetGamemodeIcon(Title);

		public override bool DisableDevTools => true;

		public override bool DisableSpawnGun => true;

		public override bool DisableManualUnragdoll => true;

		public TriggerEvent OneMinuteLeftTrigger { get; set; }

		public TriggerEvent NaturalEndTrigger { get; set; }

		public MetadataFloat Vitality { get; set; }

		public int MinimumPlayers
		{
			get
			{
				return _minimumPlayers;
			}
			set
			{
				_minimumPlayers = value;
				if (!base.IsStarted && base.IsSelected)
				{
					GamemodeManager.ValidateReadyConditions();
				}
			}
		}

		public TeamManager TeamManager => _teamManager;

		public Team SabrelakeTeam => _sabrelakeTeam;

		public Team LavaGangTeam => _lavaGangTeam;

		public TeamScoreKeeper ScoreKeeper => _scoreKeeper;

		public TeamMusicManager TeamMusicManager => _teamMusicManager;

		public MusicPlaylist MusicPlaylist => _musicPlaylist;

		public TeamLogoManager TeamLogoManager => _teamLogoManager;

		public override GroupElementData CreateSettingsGroup()
		{
			GroupElementData groupElementData = base.CreateSettingsGroup();
			GroupElementData groupElementData2 = new GroupElementData("General");
			groupElementData.AddElement(groupElementData2);
			IntElementData element = new IntElementData
			{
				Title = "Round Minutes",
				Value = _totalMinutes,
				Increment = 1,
				MinValue = 2,
				MaxValue = 60,
				OnValueChanged = delegate(int v)
				{
					_totalMinutes = v;
					_savedMinutes = v;
				}
			};
			groupElementData2.AddElement(element);
			IntElementData element2 = new IntElementData
			{
				Title = "Minimum Players",
				Value = MinimumPlayers,
				Increment = 1,
				MinValue = 1,
				MaxValue = 255,
				OnValueChanged = delegate(int v)
				{
					MinimumPlayers = v;
				}
			};
			groupElementData2.AddElement(element2);
			FloatElementData element3 = new FloatElementData
			{
				Title = "Vitality",
				Value = _savedVitality,
				Increment = 0.2f,
				MinValue = 0.2f,
				MaxValue = 100f,
				OnValueChanged = delegate(float v)
				{
					_savedVitality = v;
				}
			};
			groupElementData2.AddElement(element3);
			return groupElementData;
		}

		private void ApplyTeamSettings()
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			TeamMusicManager.ClearTeams();
			TeamLogoManager.ClearTeams();
			string iD = ((ScannableReference)FusionBoneTagReferences.TeamSabrelakeReference).Barcode.ID;
			string iD2 = ((ScannableReference)FusionBoneTagReferences.TeamLavaGangReference).Barcode.ID;
			MonoDiscReference victorySong = FusionMonoDiscReferences.SabrelakeVictoryReference;
			MonoDiscReference failureSong = FusionMonoDiscReferences.SabrelakeFailureReference;
			MonoDiscReference victorySong2 = FusionMonoDiscReferences.LavaGangVictoryReference;
			MonoDiscReference failureSong2 = FusionMonoDiscReferences.LavaGangFailureReference;
			MonoDiscReference monoDisc = FusionMonoDiscReferences.ErmReference;
			Texture logo = MenuResources.GetLogoIcon("Sabrelake");
			Texture logo2 = MenuResources.GetLogoIcon("LavaGang");
			string displayName = "Sabrelake";
			string displayName2 = "Lava Gang";
			GamemodeMusicSettings instance = GamemodeMusicSettings.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.ApplyTeamOverrides(iD, ref victorySong, ref failureSong);
				instance.ApplyTeamOverrides(iD2, ref victorySong2, ref failureSong2);
				if (!string.IsNullOrWhiteSpace(instance.TieSongOverride))
				{
					monoDisc = new MonoDiscReference(instance.TieSongOverride);
				}
			}
			GamemodeTeamSettings instance2 = GamemodeTeamSettings.Instance;
			if ((Object)(object)instance2 != (Object)null)
			{
				instance2.ApplyOverrides(iD, ref displayName, ref logo);
				instance2.ApplyOverrides(iD2, ref displayName2, ref logo2);
			}
			SabrelakeTeam.DisplayName = displayName;
			LavaGangTeam.DisplayName = displayName2;
			TeamMusicManager.SetMusic(SabrelakeTeam, new TeamMusic
			{
				WinMusic = new AudioReference(victorySong),
				LoseMusic = new AudioReference(failureSong)
			});
			TeamMusicManager.SetMusic(LavaGangTeam, new TeamMusic
			{
				WinMusic = new AudioReference(victorySong2),
				LoseMusic = new AudioReference(failureSong2)
			});
			TeamMusicManager.TieMusic = new AudioReference(monoDisc);
			TeamLogoManager.SetLogo(SabrelakeTeam, logo);
			TeamLogoManager.SetLogo(LavaGangTeam, logo2);
		}

		public override void OnGamemodeRegistered()
		{
			base.OnGamemodeRegistered();
			Instance = this;
			MultiplayerHooking.OnPlayerJoined += OnPlayerJoin;
			MultiplayerHooking.OnPlayerAction += OnPlayerAction;
			FusionOverrides.OnValidateNametag += OnValidateNametag;
			TeamManager.Register(this);
			TeamManager.OnAssignedToTeam += OnAssignedToTeam;
			TeamManager.AddTeam(SabrelakeTeam);
			TeamManager.AddTeam(LavaGangTeam);
			TeamLogoManager.Register(TeamManager);
			_scoreKeeper = new TeamScoreKeeper(TeamManager);
			ScoreKeeper.Register(base.Metadata);
			ScoreKeeper.OnScoreChanged += OnScoreChanged;
			OneMinuteLeftTrigger = new TriggerEvent("OneMinuteLeftTrigger", base.Relay, serverOnly: true);
			OneMinuteLeftTrigger.OnTriggered += OnOneMinuteLeft;
			NaturalEndTrigger = new TriggerEvent("NaturalEndTrigger", base.Relay, serverOnly: true);
			NaturalEndTrigger.OnTriggered += OnNaturalEnd;
			Vitality = new MetadataFloat("Vitality", base.Metadata);
			base.Metadata.OnMetadataChanged += OnMetadataChanged;
		}

		public override void OnGamemodeUnregistered()
		{
			base.OnGamemodeUnregistered();
			if (Instance == this)
			{
				Instance = null;
			}
			TeamManager.Unregister();
			TeamManager.OnAssignedToTeam -= OnAssignedToTeam;
			TeamLogoManager.Unregister();
			ScoreKeeper.Unregister();
			ScoreKeeper.OnScoreChanged -= OnScoreChanged;
			_scoreKeeper = null;
			MultiplayerHooking.OnPlayerJoined -= OnPlayerJoin;
			MultiplayerHooking.OnPlayerAction -= OnPlayerAction;
			FusionOverrides.OnValidateNametag -= OnValidateNametag;
			base.Metadata.OnMetadataChanged -= OnMetadataChanged;
			OneMinuteLeftTrigger.UnregisterEvent();
			NaturalEndTrigger.UnregisterEvent();
		}

		private new void OnMetadataChanged(string key, string value)
		{
			if (key == "Vitality")
			{
				OnApplyVitality();
			}
		}

		private void OnApplyVitality()
		{
			if (base.IsStarted)
			{
				LocalHealth.VitalityOverride = Vitality.GetValue();
			}
		}

		public override bool CheckReadyConditions()
		{
			return PlayerIDManager.PlayerCount >= MinimumPlayers;
		}

		public override bool CanAttack(PlayerID player)
		{
			if (!base.IsStarted)
			{
				return true;
			}
			return !TeamManager.IsTeammate(player);
		}

		private void OnAssignedToTeam(PlayerID playerId, Team team)
		{
			if (playerId.IsMe)
			{
				OnSelfAssigned(team);
			}
			FusionOverrides.ForceUpdateOverrides();
		}

		private void OnSelfAssigned(Team team)
		{
			Notifier.Send(new Notification
			{
				Title = "Team Deathmatch Assignment",
				Message = "Your team is: " + team.DisplayName,
				SaveToMenu = false,
				ShowPopup = true,
				PopupLength = 5f
			});
			FusionSceneManager.HookOnTargetLevelLoad(delegate
			{
				InitializeTeamSpawns(team);
			});
		}

		protected bool OnValidateNametag(PlayerID id)
		{
			if (!base.IsStarted)
			{
				return true;
			}
			return TeamManager.IsTeammate(id);
		}

		public void ApplyGamemodeSettings()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			_totalMinutes = _savedMinutes;
			MonoDiscReference[] array = FusionMonoDiscReferences.CombatSongReferences;
			GamemodeMusicSettings instance = GamemodeMusicSettings.Instance;
			if ((Object)(object)instance != (Object)null && instance.SongOverrides.Count > 0)
			{
				array = (MonoDiscReference[])(object)new MonoDiscReference[instance.SongOverrides.Count];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = new MonoDiscReference(instance.SongOverrides[i]);
				}
			}
			AudioReference[] playlist = AudioReference.CreateReferences(array);
			MusicPlaylist.SetPlaylist(playlist);
			MusicPlaylist.Shuffle();
			ApplyTeamSettings();
			_avatarOverride = null;
			float value = _savedVitality;
			GamemodePlayerSettings instance2 = GamemodePlayerSettings.Instance;
			if ((Object)(object)instance2 != (Object)null)
			{
				_avatarOverride = instance2.AvatarOverride;
				if (instance2.VitalityOverride.HasValue)
				{
					value = instance2.VitalityOverride.Value;
				}
			}
			Vitality.SetValue(value);
		}

		private int GetRewardedBits()
		{
			float t = (float)(PlayerIDManager.PlayerCount - 1) / 4f;
			int num = ManagedMathf.FloorToInt(ManagedMathf.Lerp(80f, 800f, t));
			int num2 = num / 10;
			int score = ScoreKeeper.GetScore(TeamManager.GetLocalTeam());
			int totalScore = ScoreKeeper.GetTotalScore();
			if (totalScore <= 0)
			{
				return 0;
			}
			float num3 = ManagedMathf.Clamp01((float)score / (float)totalScore);
			int num4 = ManagedMathf.FloorToInt((float)num * num3);
			num4 += Random.Range(-num2, num2);
			if (num4.IsNaN())
			{
				FusionLogger.ErrorLine("Prevented attempt to give invalid bit reward. Please notify a Fusion developer and send them your log.", 444);
				return 0;
			}
			return num4;
		}

		protected void OnPlayerAction(PlayerID player, PlayerActionType type, PlayerID otherPlayer = null)
		{
			if (!base.IsStarted || type != PlayerActionType.DYING_BY_OTHER_PLAYER || otherPlayer == null || otherPlayer == player)
			{
				return;
			}
			Team playerTeam = TeamManager.GetPlayerTeam(otherPlayer);
			Team playerTeam2 = TeamManager.GetPlayerTeam(player);
			if (playerTeam != playerTeam2)
			{
				if (NetworkInfo.IsHost)
				{
					ScoreKeeper.AddScore(playerTeam);
				}
				if (otherPlayer.IsMe)
				{
					AchievementManager.IncrementAchievements<KillerAchievement>();
				}
			}
		}

		protected void OnPlayerJoin(PlayerID id)
		{
			if (NetworkInfo.IsHost && base.IsStarted)
			{
				TeamManager.AssignToSmallestTeam(id);
			}
		}

		public override void OnGamemodeStarted()
		{
			base.OnGamemodeStarted();
			ApplyTeamSettings();
			if (NetworkInfo.IsHost)
			{
				ResetTeams();
				SetTeams();
			}
			_timeOfStart = TimeReferences.TimeSinceStartup;
			_oneMinuteLeft = false;
			LocalHealth.MortalityOverride = true;
			LocalControls.DisableSlowMo = true;
			if (_avatarOverride != null)
			{
				LocalAvatar.AvatarOverride = _avatarOverride;
			}
			OnApplyVitality();
		}

		public override void OnLevelReady()
		{
			ApplyGamemodeSettings();
			MusicPlaylist.StartPlaylist();
			LocalInventory.SetAmmo(10000);
			FusionOverrides.ForceUpdateOverrides();
		}

		public override void OnGamemodeStopped()
		{
			base.OnGamemodeStopped();
			MusicPlaylist.StopPlaylist();
			TeamLogoManager.ClearTeams();
			List<Team> list = TeamManager.Teams.OrderBy((Team team) => ScoreKeeper.GetScore(team)).Reverse().ToList();
			Team winningTeam = list.First();
			Team team2 = list[1];
			string text = "";
			if (!list.All((Team team) => ScoreKeeper.GetScore(team) == ScoreKeeper.GetScore(winningTeam)))
			{
				text = $"First Place: {winningTeam.DisplayName} (Score: {ScoreKeeper.GetScore(winningTeam)}) \n";
				text += $"Second Place: {team2.DisplayName} (Score: {ScoreKeeper.GetScore(team2)}) \n";
				if (list.Count > 2)
				{
					Team team3 = list[2];
					text += $"Third Place: {team3.DisplayName} (Score: {ScoreKeeper.GetScore(team3)}) \n";
				}
				text += GetTeamStatus(winningTeam);
			}
			else
			{
				text += $"Tie! (All Scored: {ScoreKeeper.GetScore(winningTeam)})";
				OnTeamTied();
			}
			Notifier.Send(new Notification
			{
				Title = "Team Deathmatch Completed",
				Message = text,
				PopupLength = 6f,
				SaveToMenu = false,
				ShowPopup = true
			});
			_timeOfStart = 0f;
			_oneMinuteLeft = false;
			LocalHealth.MortalityOverride = null;
			FusionOverrides.ForceUpdateOverrides();
			LocalAvatar.AvatarOverride = null;
			LocalHealth.VitalityOverride = null;
			LocalControls.DisableSlowMo = false;
		}

		public float GetTimeElapsed()
		{
			return TimeReferences.TimeSinceStartup - _timeOfStart;
		}

		public float GetMinutesLeft()
		{
			float timeElapsed = GetTimeElapsed();
			return (float)_totalMinutes - timeElapsed / 60f;
		}

		protected override void OnUpdate()
		{
			base.OnUpdate();
			if (!base.IsStarted)
			{
				return;
			}
			MusicPlaylist.Update();
			if (NetworkInfo.IsHost)
			{
				float minutesLeft = GetMinutesLeft();
				if (!_oneMinuteLeft && minutesLeft <= 1f)
				{
					OneMinuteLeftTrigger.TryInvoke();
					_oneMinuteLeft = true;
				}
				if (minutesLeft <= 0f)
				{
					GamemodeManager.StopGamemode();
					NaturalEndTrigger.TryInvoke();
				}
			}
		}

		private void OnOneMinuteLeft()
		{
			Notifier.Send(new Notification
			{
				Title = "Team Deathmatch Timer",
				Message = "One minute left!",
				SaveToMenu = false,
				ShowPopup = true
			});
		}

		private void OnNaturalEnd()
		{
			int rewardedBits = GetRewardedBits();
			if (rewardedBits > 0)
			{
				PointItemManager.RewardBits(rewardedBits);
			}
		}

		protected string GetTeamStatus(Team winner)
		{
			Team localTeam = TeamManager.GetLocalTeam();
			if (localTeam == winner)
			{
				OnTeamVictory(localTeam);
				return "You Won!";
			}
			OnTeamLost(localTeam);
			return "You Lost...";
		}

		protected void OnTeamVictory(Team team)
		{
			AudioReference winMusic = TeamMusicManager.GetMusic(team).WinMusic;
			if (winMusic.HasClip())
			{
				LocalAudioPlayer.Play2dOneShot(winMusic, LocalAudioPlayer.MusicSettings);
			}
			else
			{
				LocalAudioPlayer.Play2dOneShot(new AudioReference((Random.Range(0, 4) % 2 == 0) ? FusionMonoDiscReferences.LavaGangVictoryReference : FusionMonoDiscReferences.SabrelakeVictoryReference), LocalAudioPlayer.MusicSettings);
			}
		}

		protected void OnTeamLost(Team team)
		{
			AudioReference loseMusic = TeamMusicManager.GetMusic(team).LoseMusic;
			if (loseMusic.HasClip())
			{
				LocalAudioPlayer.Play2dOneShot(loseMusic, LocalAudioPlayer.MusicSettings);
			}
			else
			{
				LocalAudioPlayer.Play2dOneShot(new AudioReference((Random.Range(0, 4) % 2 == 0) ? FusionMonoDiscReferences.LavaGangFailureReference : FusionMonoDiscReferences.SabrelakeFailureReference), LocalAudioPlayer.MusicSettings);
			}
		}

		protected void OnTeamTied()
		{
			LocalAudioPlayer.Play2dOneShot(TeamMusicManager.TieMusic, LocalAudioPlayer.MusicSettings);
		}

		protected static void InitializeTeamSpawns(Team team)
		{
			BoneTagReference tag = null;
			if (team.TeamName == "Sabrelake")
			{
				tag = FusionBoneTagReferences.TeamSabrelakeReference;
			}
			else if (team.TeamName == "Lava Gang")
			{
				tag = FusionBoneTagReferences.TeamLavaGangReference;
			}
			GamemodeHelper.SetSpawnPoints(GamemodeMarker.FilterMarkers(tag));
			GamemodeHelper.TeleportToSpawnPoint();
		}

		private void OnScoreChanged(Team team, int score)
		{
			Team localTeam = TeamManager.GetLocalTeam();
			if (team == localTeam && score > 0)
			{
				Notifier.Send(new Notification
				{
					Title = "Team Deathmatch Point",
					Message = $"{localTeam.DisplayName}'s score is {score}!",
					SaveToMenu = false,
					ShowPopup = true,
					PopupLength = 0.7f
				});
			}
		}

		protected void SetTeams()
		{
			TeamManager.AssignToRandomTeams();
		}

		protected void ResetTeams()
		{
			TeamManager.UnassignAllPlayers();
			ScoreKeeper.ResetScores();
		}
	}
	public abstract class Gamemode
	{
		private bool _isStarted;

		private bool _isSelected;

		private bool _isReady;

		private readonly NetworkMetadata _metadata = new NetworkMetadata();

		private readonly TriggerRelay _relay = new TriggerRelay();

		public bool IsStarted => _isStarted;

		public bool IsSelected => _isSelected;

		public bool IsReady => _isReady;

		public abstract string Title { get; }

		public abstract string Author { get; }

		public virtual string Description => null;

		public virtual string Barcode => Author + "." + Title;

		public virtual Texture Logo => null;

		public virtual bool ManualReady => false;

		public virtual bool AutoStopOnSceneLoad { get; } = true;


		public virtual bool AutoHolsterOnDeath { get; } = true;


		public virtual bool DisableDevTools { get; }

		public virtual bool DisableSpawnGun { get; }

		public virtual bool DisableManualUnragdoll { get; }

		public NetworkMetadata Metadata => _metadata;

		public TriggerRelay Relay => _relay;

		public static event Action<Gamemode, bool> OnStartedKeyChanged;

		public static event Action<Gamemode, bool> OnSelectedKeyChanged;

		public static event Action<Gamemode, bool> OnReadyKeyChanged;

		internal void GamemodeRegistered()
		{
			MultiplayerHooking.OnMainSceneInitialized += OnMainSceneInitialized;
			MultiplayerHooking.OnPlayerJoined += OnPlayerJoinedCallback;
			MultiplayerHooking.OnPlayerLeft += OnPlayerLeftCallback;
			NetworkMetadata metadata = Metadata;
			metadata.OnTrySetMetadata = (MetadataSetDelegate)Delegate.Combine(metadata.OnTrySetMetadata, new MetadataSetDelegate(OnTrySetMetadata));
			NetworkMetadata metadata2 = Metadata;
			metadata2.OnTryRemoveMetadata = (MetadataRemoveDelegate)Delegate.Combine(metadata2.OnTryRemoveMetadata, new MetadataRemoveDelegate(OnTryRemoveMetadata));
			Metadata.OnMetadataChanged += OnMetadataChanged;
			Metadata.OnMetadataChanged += OnInternalMetadataChanged;
			Metadata.OnMetadataRemoved += OnMetadataRemoved;
			TriggerRelay relay = Relay;
			relay.OnTryInvokeTrigger = (TriggerRelay.TriggerDelegate)Delegate.Combine(relay.OnTryInvokeTrigger, new TriggerRelay.TriggerDelegate(OnTryInvokeTrigger));
			TriggerRelay relay2 = Relay;
			relay2.OnTryInvokeTriggerWithValue = (TriggerRelay.TriggerValueDelegate)Delegate.Combine(relay2.OnTryInvokeTriggerWithValue, new TriggerRelay.TriggerValueDelegate(OnTryInvokeTriggerWithValue));
			OnGamemodeRegistered();
		}

		internal void GamemodeUnregistered()
		{
			MultiplayerHooking.OnMainSceneInitialized -= OnMainSceneInitialized;
			NetworkMetadata metadata = Metadata;
			metadata.OnTrySetMetadata = (MetadataSetDelegate)Delegate.Remove(metadata.OnTrySetMetadata, new MetadataSetDelegate(OnTrySetMetadata));
			NetworkMetadata metadata2 = Metadata;
			metadata2.OnTryRemoveMetadata = (MetadataRemoveDelegate)Delegate.Remove(metadata2.OnTryRemoveMetadata, new MetadataRemoveDelegate(OnTryRemoveMetadata));
			Metadata.OnMetadataChanged -= OnMetadataChanged;
			Metadata.OnMetadataChanged -= OnInternalMetadataChanged;
			Metadata.OnMetadataRemoved -= OnMetadataRemoved;
			TriggerRelay relay = Relay;
			relay.OnTryInvokeTrigger = (TriggerRelay.TriggerDelegate)Delegate.Remove(relay.OnTryInvokeTrigger, new TriggerRelay.TriggerDelegate(OnTryInvokeTrigger));
			TriggerRelay relay2 = Relay;
			relay2.OnTryInvokeTriggerWithValue = (TriggerRelay.TriggerValueDelegate)Delegate.Remove(relay2.OnTryInvokeTriggerWithValue, new TriggerRelay.TriggerValueDelegate(OnTryInvokeTriggerWithValue));
			OnGamemodeUnregistered();
		}

		private bool OnTryInvokeTrigger(string name)
		{
			GamemodeSender.SendGamemodeTriggerResponse(Barcode, name);
			return true;
		}

		private bool OnTryInvokeTriggerWithValue(string name, string value)
		{
			GamemodeSender.SendGamemodeTriggerResponse(Barcode, name, value);
			return true;
		}

		private bool OnTrySetMetadata(string key, string value)
		{
			if (!NetworkInfo.IsHost)
			{
				return false;
			}
			GamemodeSender.SendGamemodeMetadataSet(Barcode, key, value);
			return true;
		}

		private bool OnTryRemoveMetadata(string key)
		{
			if (!NetworkInfo.IsHost)
			{
				return false;
			}
			GamemodeSender.SendGamemodeMetadataRemove(Barcode, key);
			return true;
		}

		public virtual void OnGamemodeSelected()
		{
		}

		public virtual void OnGamemodeDeselected()
		{
		}

		public virtual void OnGamemodeStarted()
		{
		}

		public virtual void OnGamemodeStopped()
		{
		}

		public virtual void OnGamemodeReady()
		{
		}

		public virtual void OnGamemodeUnready()
		{
		}

		public virtual void OnGamemodeRegistered()
		{
		}

		public virtual void OnGamemodeUnregistered()
		{
		}

		public virtual void OnMainSceneInitialized()
		{
		}

		public virtual void OnLevelReady()
		{
		}

		protected virtual void OnPlayerJoined(PlayerID playerId)
		{
		}

		protected virtual void OnPlayerLeft(PlayerID playerId)
		{
		}

		private void OnPlayerJoinedCallback(PlayerID playerId)
		{
			if (IsStarted)
			{
				OnPlayerJoined(playerId);
			}
		}

		private void OnPlayerLeftCallback(PlayerID playerId)
		{
			if (IsStarted)
			{
				OnPlayerLeft(playerId);
			}
		}

		public virtual GroupElementData CreateSettingsGroup()
		{
			return new GroupElementData
			{
				Title = Title
			};
		}

		public virtual bool CheckReadyConditions()
		{
			return true;
		}

		public void FixedUpdate()
		{
			OnFixedUpdate();
		}

		protected virtual void OnFixedUpdate()
		{
		}

		public void Update()
		{
			OnUpdate();
		}

		protected virtual void OnUpdate()
		{
		}

		public void LateUpdate()
		{
			OnLateUpdate();
		}

		protected virtual void OnLateUpdate()
		{
		}

		private void OnInternalMetadataChanged(string key, string value)
		{
			bool flag = value == bool.TrueString;
			switch (key)
			{
			case "Gamemode.Started":
				if (_isStarted != flag)
				{
					_isStarted = flag;
					Gamemode.OnStartedKeyChanged?.Invoke(this, _isStarted);
				}
				break;
			case "Gamemode.Selected":
				if (_isSelected != flag)
				{
					_isSelected = flag;
					Gamemode.OnSelectedKeyChanged?.Invoke(this, _isSelected);
				}
				break;
			case "Gamemode.Ready":
				if (_isReady != flag)
				{
					_isReady = flag;
					Gamemode.OnReadyKeyChanged?.Invoke(this, _isReady);
				}
				break;
			}
		}

		protected virtual void OnMetadataChanged(string key, string value)
		{
		}

		protected virtual void OnMetadataRemoved(string key, string value)
		{
		}

		public void ClearMetadata()
		{
			Metadata.ClearLocalMetadataExcept(GamemodeKeys.PersistentKeys);
		}

		public virtual bool CanAttack(PlayerID player)
		{
			return true;
		}
	}
	public static class GamemodeConditionsChecker
	{
		internal static void OnInitializeMelon()
		{
			GamemodeManager.OnGamemodeChanged += OnGamemodeChanged;
			MultiplayerHooking.OnPlayerJoined += OnPlayerCountChanged;
			MultiplayerHooking.OnPlayerLeft += OnPlayerCountChanged;
			MultiplayerHooking.OnMainSceneInitialized += AutoCheckConditions;
		}

		private static void OnGamemodeChanged(Gamemode gamemode)
		{
			AutoCheckConditions();
		}

		private static void OnPlayerCountChanged(PlayerID player)
		{
			AutoCheckConditions();
		}

		private static void AutoCheckConditions()
		{
			if (GamemodeManager.ActiveGamemode != null && !GamemodeManager.ActiveGamemode.ManualReady)
			{
				GamemodeManager.ValidateReadyConditions();
			}
		}
	}
	public static class GamemodeHelper
	{
		public static void StartGamemodeServer(Gamemode gamemode)
		{
			if (NetworkInfo.HasServer)
			{
				NetworkHelper.Disconnect();
			}
			NetworkHelper.StartServer();
			DelayUtilities.InvokeDelayed(delegate
			{
				FusionSceneManager.HookOnLevelLoad(delegate
				{
					GamemodeManager.SelectGamemode(gamemode);
				});
			}, 10);
		}

		public static void SetSpawnPoint(GamemodeMarker marker)
		{
			FusionPlayer.SetSpawnPoints(((Component)marker).transform);
		}

		public static void SetSpawnPoints(IEnumerable<GamemodeMarker> markers)
		{
			Transform[] array = (Transform[])(object)new Transform[markers.Count()];
			for (int i = 0; i < markers.Count(); i++)
			{
				array[i] = ((Component)markers.ElementAt(i)).transform;
			}
			FusionPlayer.SetSpawnPoints(array);
		}

		public static void ResetSpawnPoints()
		{
			FusionPlayer.ResetSpawnPoints();
		}

		public static void TeleportToSpawnPoint()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (FusionPlayer.TryGetSpawnPoint(out var point))
			{
				LocalPlayer.TeleportToPosition(point.position);
			}
			else
			{
				LocalPlayer.TeleportToCheckpoint();
			}
		}

		public static void CreateMarkers(Vector3[] positions, params string[] teams)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			foreach (Vector3 position in positions)
			{
				GameObject val = new GameObject("Gamemode Marker");
				val.transform.position = position;
				foreach (string text in teams)
				{
					GamemodeMarker gamemodeMarker = val.AddComponent<GamemodeMarker>();
					if (!string.IsNullOrWhiteSpace(text))
					{
						gamemodeMarker.AddTeam(text);
					}
				}
			}
		}
	}
	public static class GamemodeManager
	{
		private static Gamemode _activeGamemode = null;

		private static float _startTimer = 30f;

		private static bool _startTimerActive = false;

		public const float DefaultStartTime = 30f;

		public const string NotificationTag = "Gamemode";

		public static Gamemode ActiveGamemode
		{
			get
			{
				return _activeGamemode;
			}
			private set
			{
				if (_activeGamemode != null)
				{
					_activeGamemode.OnGamemodeDeselected();
					_activeGamemode.ClearMetadata();
				}
				_activeGamemode = value;
				if (value != null)
				{
					value.ClearMetadata();
					value.OnGamemodeSelected();
				}
				GamemodeManager.OnGamemodeChanged.InvokeSafe(value, "executing hook OnGamemodeChanged");
				SendGamemodeChangeNotification();
			}
		}

		public static bool IsGamemodeStarted
		{
			get
			{
				if (ActiveGamemode != null)
				{
					return ActiveGamemode.IsStarted;
				}
				return false;
			}
		}

		public static bool IsGamemodeReady
		{
			get
			{
				if (ActiveGamemode != null)
				{
					return ActiveGamemode.IsReady;
				}
				return false;
			}
		}

		public static float StartTimer
		{
			get
			{
				return _startTimer;
			}
			set
			{
				_startTimer = value;
				GamemodeManager.OnStartTimerChanged?.InvokeSafe(value, "executing OnStartTimerChanged hook");
			}
		}

		public static bool StartTimerActive => _startTimerActive;

		public static IReadOnlyCollection<Gamemode> Gamemodes => GamemodeRegistration.Gamemodes;

		public static event Action<Gamemode> OnGamemodeChanged;

		public static event Action OnGamemodeStarted;

		public static event Action OnGamemodeStopped;

		public static event Action OnGamemodeReady;

		public static event Action OnGamemodeUnready;

		public static event Action<float> OnStartTimerChanged;

		public static void OnInitializeMelon()
		{
			Gamemode.OnStartedKeyChanged += OnStartedKeyChanged;
			Gamemode.OnSelectedKeyChanged += OnSelectedKeyChanged;
			Gamemode.OnReadyKeyChanged += OnReadyKeyChanged;
			MultiplayerHooking.OnMainSceneInitialized += OnMainSceneInitialized;
			MultiplayerHooking.OnTargetLevelLoaded += OnTargetLevelLoaded;
			MultiplayerHooking.OnDisconnected += OnDisconnect;
		}

		private static void OnTargetLevelLoaded()
		{
			if (IsGamemodeStarted)
			{
				ActiveGamemode.OnLevelReady();
			}
		}

		private static void OnMainSceneInitialized()
		{
			if (NetworkInfo.IsHost && IsGamemodeStarted && ActiveGamemode.AutoStopOnSceneLoad)
			{
				StopGamemode();
			}
		}

		private static void OnDisconnect()
		{
			StopGamemode();
			Gamemode activeGamemode = ActiveGamemode;
			if (activeGamemode != null)
			{
				activeGamemode.Metadata.ForceSetLocalMetadata("Gamemode.Ready", bool.FalseString);
				activeGamemode.Metadata.ForceSetLocalMetadata("Gamemode.Started", bool.FalseString);
				activeGamemode.Metadata.ForceSetLocalMetadata("Gamemode.Selected", bool.FalseString);
			}
		}

		private static void SendGamemodeChangeNotification()
		{
			Notifier.Cancel("Gamemode");
			if (ActiveGamemode != null)
			{
				Notifier.Send(new Notification
				{
					Message = ActiveGamemode.Title + " is selected! Waiting until conditions are met...",
					Title = "Gamemode Selected",
					Tag = "Gamemode",
					Type = NotificationType.INFORMATION,
					ShowPopup = true,
					SaveToMenu = false,
					PopupLength = 1.5f
				});
			}
			else
			{
				Notifier.Send(new Notification
				{
					Message = "The server is now in Sandbox mode!",
					Title = "Gamemode Deselected",
					Tag = "Gamemode",
					Type = NotificationType.INFORMATION,
					ShowPopup = true,
					SaveToMenu = false,
					PopupLength = 1.5f
				});
			}
		}

		private static void OnStartedKeyChanged(Gamemode gamemode, bool started)
		{
			if (started)
			{
				gamemode.OnGamemodeStarted();
				if (FusionSceneManager.HasTargetLoaded())
				{
					gamemode.OnLevelReady();
				}
				GamemodeManager.OnGamemodeStarted?.InvokeSafe("executing OnGamemodeStarted");
			}
			else
			{
				gamemode.OnGamemodeStopped();
				GamemodeManager.OnGamemodeStopped?.InvokeSafe("executing OnGamemodeStopped");
				if (IsGamemodeReady)
				{
					StartReadyTimer();
				}
			}
		}

		private static void OnSelectedKeyChanged(Gamemode gamemode, bool selected)
		{
			if (selected)
			{
				ActiveGamemode = gamemode;
			}
			else
			{
				ActiveGamemode = null;
			}
		}

		private static void OnReadyKeyChanged(Gamemode gamemode, bool ready)
		{
			if (ready)
			{
				gamemode.OnGamemodeReady();
				GamemodeManager.OnGamemodeReady?.InvokeSafe("executing OnGamemodeReady hook");
			}
			else
			{
				gamemode.OnGamemodeUnready();
				GamemodeManager.OnGamemodeUnready?.InvokeSafe("executing OnGamemodeUnready hook");
			}
			if (!IsGamemodeStarted)
			{
				if (ready)
				{
					StartReadyTimer();
				}
				else
				{
					StopReadyTimer();
				}
				gamemode.ClearMetadata();
			}
		}

		private static void StartReadyTimer()
		{
			if (ActiveGamemode != null)
			{
				Notifier.Cancel("Gamemode");
				Notifier.Send(new Notification
				{
					Message = $"{ActiveGamemode.Title} is ready! Starting in {GetInitialStartTime()} seconds!",
					Title = "Gamemode Ready",
					Tag = "Gamemode",
					Type = NotificationType.SUCCESS,
					ShowPopup = true,
					SaveToMenu = false,
					PopupLength = 2f
				});
			}
			_startTimerActive = true;
			StartTimer = GetInitialStartTime();
		}

		private static void StopReadyTimer()
		{
			if (ActiveGamemode != null)
			{
				Notifier.Cancel("Gamemode");
				Notifier.Send(new Notification
				{
					Message = ActiveGamemode.Title + " is no longer ready.",
					Title = "Gamemode Unready",
					Tag = "Gamemode",
					Type = NotificationType.ERROR,
					ShowPopup = true,
					PopupLength = 2f
				});
			}
			_startTimerActive = false;
			StartTimer = GetInitialStartTime();
		}

		private static float GetInitialStartTime()
		{
			if (!NetworkInfo.HasServer)
			{
				return 30f;
			}
			return LobbyInfoManager.LobbyInfo.TimeBetweenGamemodeRounds;
		}

		public static void SelectGamemode(Gamemode gamemode)
		{
			if (NetworkInfo.IsHost)
			{
				if (ActiveGamemode != null)
				{
					DeselectGamemode();
				}
				gamemode.Metadata.TrySetMetadata("Gamemode.Selected", bool.TrueString);
			}
		}

		public static void DeselectGamemode()
		{
			if (NetworkInfo.IsHost && ActiveGamemode != null)
			{
				if (IsGamemodeStarted)
				{
					StopGamemode();
				}
				if (IsGamemodeReady)
				{
					UnreadyGamemode();
				}
				ActiveGamemode.Metadata.TrySetMetadata("Gamemode.Selected", bool.FalseString);
			}
		}

		public static void StartGamemode()
		{
			if (NetworkInfo.IsHost && ActiveGamemode != null)
			{
				if (IsGamemodeStarted)
				{
					StopGamemode();
				}
				if (!IsGamemodeReady)
				{
					ReadyGamemode();
				}
				ActiveGamemode.Metadata.TrySetMetadata("Gamemode.Started", bool.TrueString);
			}
		}

		public static void StopGamemode()
		{
			if (NetworkInfo.IsHost && IsGamemodeStarted)
			{
				ActiveGamemode.Metadata.TrySetMetadata("Gamemode.Started", bool.FalseString);
			}
		}

		public static void ValidateReadyConditions()
		{
			if (NetworkInfo.IsHost && ActiveGamemode != null)
			{
				bool flag = ActiveGamemode.CheckReadyConditions();
				if (flag && !IsGamemodeReady)
				{
					ReadyGamemode();
				}
				else if (!flag && IsGamemodeReady)
				{
					UnreadyGamemode();
				}
			}
		}

		public static void ReadyGamemode()
		{
			if (NetworkInfo.IsHost && ActiveGamemode != null && !IsGamemodeReady)
			{
				ActiveGamemode.Metadata.TrySetMetadata("Gamemode.Ready", bool.TrueString);
			}
		}

		public static void UnreadyGamemode()
		{
			if (NetworkInfo.IsHost && ActiveGamemode != null && IsGamemodeReady)
			{
				ActiveGamemode.Metadata.TrySetMetadata("Gamemode.Ready", bool.FalseString);
			}
		}

		internal static void OnFixedUpdate()
		{
			ActiveGamemode?.FixedUpdate();
		}

		internal static void OnUpdate()
		{
			ActiveGamemode?.Update();
			if (!FusionSceneManager.IsLoading() && !IsGamemodeStarted && IsGamemodeReady && _startTimerActive)
			{
				StartTimer -= TimeReferences.DeltaTime;
				if (StartTimer <= 0f)
				{
					StartTimer = 0f;
					_startTimerActive = false;
					StartGamemode();
				}
			}
		}

		internal static void OnLateUpdate()
		{
			ActiveGamemode?.LateUpdate();
		}

		public static bool TryGetGamemode(string barcode, out Gamemode gamemode)
		{
			return GamemodeRegistration.TryGetGamemode(barcode, out gamemode);
		}

		public static Gamemode GetGamemode(string barcode)
		{
			TryGetGamemode(barcode, out var gamemode);
			return gamemode;
		}

		public static bool TryGetGamemode<TGamemode>(out TGamemode gamemode) where TGamemode : Gamemode
		{
			foreach (Gamemode gamemode2 in Gamemodes)
			{
				if (gamemode2 is TGamemode)
				{
					gamemode = gamemode2 as TGamemode;
					return true;
				}
			}
			gamemode = null;
			return false;
		}
	}
	public static class GamemodeRegistration
	{
		public static List<Gamemode> Gamemodes { get; private set; } = new List<Gamemode>();


		public static Dictionary<string, Gamemode> GamemodeLookup { get; private set; } = new Dictionary<string, Gamemode>();


		public static void LoadGamemodes(Assembly assembly)
		{
			if (assembly == null)
			{
				throw new NullReferenceException("Tried loading gamemodes from a null assembly!");
			}
			AssemblyUtilities.LoadAllValid<Gamemode>(assembly, RegisterGamemode);
		}

		public static void RegisterGamemode<T>() where T : Gamemode
		{
			RegisterGamemode(typeof(T));
		}

		private static void RegisterGamemode(Type type)
		{
			Gamemode gamemode = Activator.CreateInstance(type) as Gamemode;
			gamemode.GamemodeRegistered();
			Gamemodes.Add(gamemode);
			GamemodeLookup.Add(gamemode.Barcode, gamemode);
		}

		public static Dictionary<string, Dictionary<string, string>> GetExistingMetadata()
		{
			Dictionary<string, Dictionary<string, string>> dictionary = new Dictionary<string, Dictionary<string, string>>();
			for (int i = 0; i < Gamemodes.Count; i++)
			{
				Gamemode gamemode = Gamemodes[i];
				if (!gamemode.IsSelected)
				{
					continue;
				}
				string barcode = gamemode.Barcode;
				Dictionary<string, string> dictionary2 = new Dictionary<string, string>();
				foreach (KeyValuePair<string, string> item in gamemode.Metadata.LocalDictionary)
				{
					dictionary2.Add(item.Key, item.Value);
				}
				dictionary.Add(barcode, dictionary2);
			}
			return dictionary;
		}

		public static bool TryGetGamemode(string barcode, out Gamemode gamemode)
		{
			return GamemodeLookup.TryGetValue(barcode, out gamemode);
		}

		public static void PopulateGamemodeMetadatas(Dictionary<string, Dictionary<string, string>> metadatas)
		{
			foreach (KeyValuePair<string, Dictionary<string, string>> metadata in metadatas)
			{
				if (!TryGetGamemode(metadata.Key, out var gamemode))
				{
					continue;
				}
				foreach (KeyValuePair<string, string> item in metadata.Value)
				{
					gamemode.Metadata.ForceSetLocalMetadata(item.Key, item.Value);
				}
			}
		}
	}
	[Serializable]
	public class GamemodeLevelRotations
	{
		[JsonPropertyName("gamemodeBarcode")]
		public string GamemodeBarcode { get; set; }

		[JsonPropertyName("levelRotations")]
		public List<LevelRotation> LevelRotations { get; set; } = new List<LevelRotation>();

	}
	[Serializable]
	public class GamemodeRoundSettings
	{
		[JsonPropertyName("levelRotations")]
		public List<GamemodeLevelRotations> LevelRotations { get; set; } = new List<GamemodeLevelRotations>();


		[JsonPropertyName("roundsBeforeNextLevel")]
		public int RoundsBeforeNextLevel { get; set; } = 3;


		[JsonPropertyName("shuffleLevels")]
		public bool ShuffleLevels { get; set; } = true;


		[JsonPropertyName("timeBetweenRounds")]
		public int TimeBetweenRounds { get; set; } = 30;


		public GamemodeLevelRotations GetRotationsByGamemode(string gamemodeBarcode)
		{
			foreach (GamemodeLevelRotations levelRotation in LevelRotations)
			{
				if (levelRotation.GamemodeBarcode == gamemodeBarcode)
				{
					return levelRotation;
				}
			}
			GamemodeLevelRotations gamemodeLevelRotations = new GamemodeLevelRotations
			{
				GamemodeBarcode = gamemodeBarcode
			};
			LevelRotations.Add(gamemodeLevelRotations);
			return gamemodeLevelRotations;
		}
	}
	public static class GamemodeRoundManager
	{
		private static GamemodeRoundSettings _settings = new GamemodeRoundSettings();

		public const string FileName = "gamemodeRoundSettings.json";

		private static int _rotationRounds = 0;

		private static int _levelIndex = 0;

		public static GamemodeRoundSettings Settings => _settings;

		public static LevelRotation ActiveRotation { get; set; } = null;


		internal static void OnInitializeMelon()
		{
			LoadSettings();
			GamemodeManager.OnGamemodeStopped += OnGamemodeStopped;
			GamemodeManager.OnGamemodeChanged += OnGamemodeChanged;
			GamemodeManager.OnGamemodeUnready += OnGamemodeUnready;
		}

		private static void OnGamemodeUnready()
		{
			_rotationRounds = 0;
		}

		private static void OnGamemodeChanged(Gamemode gamemode)
		{
			_rotationRounds = 0;
			if (gamemode != null && ActiveRotation != null && !Settings.GetRotationsByGamemode(gamemode.Barcode).LevelRotations.Contains(ActiveRotation))
			{
				ActiveRotation = null;
			}
		}

		private static void OnGamemodeStopped()
		{
			if (NetworkInfo.IsHost && ActiveRotation != null)
			{
				_rotationRounds++;
				if (_rotationRounds >= Settings.RoundsBeforeNextLevel)
				{
					_rotationRounds = 0;
					NextLevel();
				}
			}
		}

		private static void NextLevel()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			if (ActiveRotation != null && ActiveRotation.LevelBarcodes.Count > 0)
			{
				if (Settings.ShuffleLevels)
				{
					_levelIndex = PickRandomIndex(ActiveRotation.LevelBarcodes.Count, _levelIndex);
				}
				else
				{
					_levelIndex = (_levelIndex + 1) % ActiveRotation.LevelBarcodes.Count;
				}
				SceneStreamer.Load(new Barcode(ActiveRotation.LevelBarcodes[_levelIndex]), (Barcode)null);
			}
		}

		private static int PickRandomIndex(int count, int previousIndex)
		{
			for (int i = 0; i < 3; i++)
			{
				int num = Random.Range(0, count);
				if (num != previousIndex)
				{
					return num;
				}
			}
			return previousIndex;
		}

		public static void SaveSettings()
		{
			DataSaver.WriteJsonToFile("gamemodeRoundSettings.json", Settings);
		}

		public static void LoadSettings()
		{
			GamemodeRoundSettings gamemodeRoundSettings = DataSaver.ReadJsonFromFile<GamemodeRoundSettings>("gamemodeRoundSettings.json");
			if (gamemodeRoundSettings != null)
			{
				_settings = gamemodeRoundSettings;
			}
		}
	}
	[Serializable]
	public class LevelRotation
	{
		[JsonPropertyName("name")]
		public string Name { get; set; } = "New Level Rotation";


		[JsonPropertyName("levelBarcodes")]
		public List<string> LevelBarcodes { get; set; } = new List<string>();

	}
	public class MusicPlaylist
	{
		private AudioReference[] _songs;

		private int _currentTrack = -1;

		private float _volume = 0.2f;

		private bool _loopSingle;

		private bool _isActive;

		private bool _loadingTrack;

		public AudioReference[] Songs => _songs;

		public int CurrentTrack => _currentTrack;

		public float Volume
		{
			get
			{
				return _volume;
			}
			set
			{
				_volume = value;
			}
		}

		public bool LoopSingle
		{
			get
			{
				return _loopSingle;
			}
			set
			{
				_loopSingle = value;
			}
		}

		public bool IsActive => _isActive;

		public void StartPlaylist()
		{
			_isActive = true;
			_loadingTrack = false;
			NextTrack();
		}

		public void StopPlaylist()
		{
			StopMusic();
			_isActive = false;
			_loadingTrack = false;
		}

		private void PlayMusic()
		{
			_loadingTrack = true;
			GetCurrentTrack().LoadClip(delegate(AudioClip clip)
			{
				_loadingTrack = false;
				if (IsActive)
				{
					Audio2dPlugin.Audio2dManager.CueOverrideMusic(clip, Volume, 0.2f, 0.2f, LoopSingle, false);
				}
			});
		}

		private void StopMusic()
		{
			_loadingTrack = false;
			Audio2dManager audio2dManager = Audio2dPlugin.Audio2dManager;
			bool num = (Object)(object)audio2dManager._overridenMusicClip == (Object)null;
			audio2dManager.StopOverrideMusic();
			if (num)
			{
				audio2dManager.StopMusic(0.2f);
			}
		}

		public void NextTrack()
		{
			if (!IsActive)
			{
				return;
			}
			if (Songs == null)
			{
				_currentTrack = -1;
				return;
			}
			_currentTrack++;
			if (_currentTrack >= Songs.Length)
			{
				_currentTrack = 0;
			}
			PlayMusic();
		}

		public void PreviousTrack()
		{
			if (!IsActive)
			{
				return;
			}
			if (Songs == null)
			{
				_currentTrack = -1;
				return;
			}
			_currentTrack--;
			if (_currentTrack < 0)
			{
				_currentTrack = Songs.Length - 1;
			}
			PlayMusic();
		}

		public AudioReference GetCurrentTrack()
		{
			if (CurrentTrack < 0)
			{
				return default(AudioReference);
			}
			if (Songs == null)
			{
				return default(AudioReference);
			}
			return Songs[CurrentTrack];
		}

		public void Update()
		{
			if (!IsActive || _loadingTrack)
			{
				return;
			}
			bool flag;
			if (flag = Audio2dPlugin.Audio2dManager._isOverride)
			{
				AmbAndMusic currentAmbAndMusic = GetCurrentAmbAndMusic();
				if (currentAmbAndMusic == null || !currentAmbAndMusic.ambMus.isPlaying)
				{
					flag = false;
				}
			}
			if (!flag)
			{
				NextTrack();
			}
		}

		private static AmbAndMusic GetCurrentAmbAndMusic()
		{
			Audio2dManager audio2dManager = Audio2dPlugin.Audio2dManager;
			int curMus = audio2dManager._curMus;
			if (curMus > 0 && curMus < ((Il2CppArrayBase<AmbAndMusic>)(object)audio2dManager.ambAndMusics).Length)
			{
				return ((Il2CppArrayBase<AmbAndMusic>)(object)audio2dManager.ambAndMusics)[curMus];
			}
			return null;
		}

		public void SetPlaylist(params AudioReference[] songs)
		{
			_songs = songs;
			_currentTrack = -1;
		}

		public void Shuffle()
		{
			if (Songs != null)
			{
				Songs.Shuffle();
			}
		}
	}
	public sealed class PlayerScoreKeeper : ScoreKeeper<byte>
	{
		public event Action<PlayerID, int> OnPlayerScoreChanged;

		protected override void OnRegistered()
		{
			base.OnScoreChanged += OnByteScoreChanged;
			MultiplayerHooking.OnPlayerLeft += OnPlayerLeft;
		}

		protected override void OnUnregistered()
		{
			base.OnScoreChanged -= OnByteScoreChanged;
			MultiplayerHooking.OnPlayerLeft -= OnPlayerLeft;
		}

		private void OnByteScoreChanged(byte smallID, int score)
		{
			PlayerID playerID = PlayerIDManager.GetPlayerID(smallID);
			if (playerID != null)
			{
				this.OnPlayerScoreChanged?.InvokeSafe(playerID, score, "executing PlayerScoreKeeper.OnPlayerScoreChanged");
			}
		}

		private void OnPlayerLeft(PlayerID playerID)
		{
			RemoveScoreMetadata(playerID.SmallID);
		}

		public override string GetKeyWithProperty(byte property)
		{
			return KeyHelper.GetKeyFromPlayer(base.Key, property);
		}

		public override byte GetPropertyWithKey(string key)
		{
			return KeyHelper.GetPlayerFromKey(key);
		}

		public IReadOnlyList<PlayerID> GetPlacedPlayers()
		{
			List<PlayerID> list = new List<PlayerID>(PlayerIDManager.PlayerIDs).OrderBy((PlayerID playerID) => GetScore(playerID.SmallID)).ToList();
			list.Reverse();
			return list;
		}

		public IReadOnlyList<PlayerID> GetOrderedPlayers()
		{
			return new List<PlayerID>(PlayerIDManager.PlayerIDs).OrderBy((PlayerID playerID) => GetScore(playerID.SmallID)).ToList();
		}

		public PlayerID GetPlayerByPlace(int place)
		{
			IReadOnlyList<PlayerID> placedPlayers = GetPlacedPlayers();
			if (placedPlayers != null && placedPlayers.Count > place)
			{
				return placedPlayers[place];
			}
			return null;
		}

		public int GetPlace(PlayerID playerID)
		{
			if (playerID == null)
			{
				return -1;
			}
			IReadOnlyList<PlayerID> placedPlayers = GetPlacedPlayers();
			if (placedPlayers == null)
			{
				return -1;
			}
			for (int i = 0; i < placedPlayers.Count; i++)
			{
				if (placedPlayers[i] == playerID)
				{
					return i;
				}
			}
			return -1;
		}

		public void SetScore(PlayerID playerID, int score)
		{
			if (playerID != null)
			{
				SetScore(playerID.SmallID, score);
			}
		}

		public int GetScore(PlayerID playerID)
		{
			if (playerID == null)
			{
				return 0;
			}
			return GetScore(playerID.SmallID);
		}

		public void AddScore(PlayerID playerID, int amount = 1)
		{
			if (playerID != null)
			{
				AddScore(playerID.SmallID, amount);
			}
		}

		public void SubtractScore(PlayerID playerID, int amount = 1)
		{
			if (playerID != null)
			{
				SubtractScore(playerID.SmallID, amount);
			}
		}
	}
	public abstract class ScoreKeeper<TProperty>
	{
		private readonly Dictionary<TProperty, MetadataInt> _propertyToScore = new Dictionary<TProperty, MetadataInt>();

		private NetworkMetadata _metadata;

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


		public event Action<TProperty, int> OnScoreChanged;

		public abstract string GetKeyWithProperty(TProperty property);

		public abstract TProperty GetPropertyWithKey(string key);

		public void Register(NetworkMetadata metadata)
		{
			Register(metadata, "Score");
		}

		public void Register(NetworkMetadata metadata, string key)
		{
			_metadata = metadata;
			_metadata.OnMetadataChanged += OnMetadataChanged;
			_metadata.OnMetadataRemoved += OnMetadataRemoved;
			Key = key;
			OnRegistered();
		}

		public void Unregister()
		{
			_metadata.OnMetadataChanged -= OnMetadataChanged;
			_metadata.OnMetadataRemoved -= OnMetadataRemoved;
			_metadata = null;
			OnUnregistered();
		}

		protected virtual void OnRegistered()
		{
		}

		protected virtual void OnUnregistered()
		{
		}

		private void OnMetadataChanged(string key, string value)
		{
			if (!KeyHelper.KeyMatchesVariable(key, Key))
			{
				return;
			}
			TProperty propertyWithKey = GetPropertyWithKey(key);
			if (propertyWithKey != null)
			{
				int arg = 0;
				if (int.TryParse(value, out var result))
				{
					arg = result;
				}
				this.OnScoreChanged?.Invoke(propertyWithKey, arg);
			}
		}

		private void OnMetadataRemoved(string key, string value)
		{
			if (!KeyHelper.KeyMatchesVariable(key, Key))
			{
				return;
			}
			foreach (KeyValuePair<TProperty, MetadataInt> item in _propertyToScore.Where((KeyValuePair<TProperty, MetadataInt> pair) => pair.Value.Key == key))
			{
				if (item.Key != null)
				{
					_propertyToScore.Remove(item.Key);
				}
			}
		}

		public MetadataInt GetScoreMetadata(TProperty property)
		{
			if (property == null)
			{
				return null;
			}
			if (!_propertyToScore.TryGetValue(property, out var value))
			{
				value = new MetadataInt(GetKeyWithProperty(property), _metadata);
				_propertyToScore[property] = value;
			}
			return value;
		}

		public void RemoveScoreMetadata(TProperty property)
		{
			if (property != null)
			{
				_propertyToScore.Remove(property);
			}
		}

		public void SetScore(TProperty property, int score)
		{
			if (property != null)
			{
				GetScoreMetadata(property).SetValue(score);
			}
		}

		public int GetScore(TProperty property)
		{
			if (property == null)
			{
				return 0;
			}
			return GetScoreMetadata(property).GetValue();
		}

		public void AddScore(TProperty property, int amount = 1)
		{
			if (property != null)
			{
				int score = GetScore(property) + amount;
				SetScore(property, score);
			}
		}

		public void SubtractScore(TProperty property, int amount = 1, bool allowNegatives = false)
		{
			if (property != null)
			{
				int num = GetScore(property) - amount;
				if (!allowNegatives && num < 0)
				{
					num = 0;
				}
				SetScore(property, num);
			}
		}

		public int GetTotalScore()
		{
			int num = 0;
			foreach (MetadataInt value in _propertyToScore.Values)
			{
				num += value.GetValue();
			}
			return num;
		}

		public void ResetScores()
		{
			foreach (MetadataInt value in _propertyToScore.Values)
			{
				value.SetValue(0);
				value.Remove();
			}
		}
	}
	public sealed class TeamScoreKeeper : ScoreKeeper<Team>
	{
		private readonly TeamManager _teamManager;

		public TeamManager TeamManager => _teamManager;

		public TeamScoreKeeper(TeamManager teamManager)
		{
			_teamManager = teamManager;
		}

		public override string GetKeyWithProperty(Team property)
		{
			return KeyHelper.GetKeyWithProperty(base.Key, property.TeamName);
		}

		public override Team GetPropertyWithKey(string key)
		{
			return TeamManager.GetTeamByName(KeyHelper.GetPropertyFromKey(key));
		}
	}
	public class Team
	{
		private string _displayName;

		private readonly HashSet<byte> _players = new HashSet<byte>();

		public string TeamName { get; set; }

		public string DisplayName
		{
			get
			{
				return _displayName ?? TeamName;
			}
			set
			{
				_displayName = value;
			}
		}

		public HashSet<byte> Players => _players;

		public int PlayerCount => _players.Count;

		public Team(string teamName)
		{
			TeamName = teamName;
		}

		public bool HasPlayer(byte smallID)
		{
			return Players.Contains(smallID);
		}

		public bool HasPlayer(PlayerID playerID)
		{
			return HasPlayer(playerID.SmallID);
		}

		public void ForceAddPlayer(byte smallID)
		{
			_players.Add(smallID);
		}

		public void ForceAddPlayer(PlayerID playerID)
		{
			_players.Add(playerID.SmallID);
		}

		public void ForceRemovePlayer(byte smallID)
		{
			_players.Remove(smallID);
		}

		public void ForceRemovePlayer(PlayerID playerID)
		{
			_players.Remove(playerID.SmallID);
		}
	}
	public class TeamLogoManager
	{
		private readonly Dictionary<Team, Texture> _teamToLogo = new Dictionary<Team, Texture>();

		private TeamManager _teamManager;

		private bool _showTeammateLogos = true;

		private bool _showOpponentLogos;

		public TeamManager TeamManager => _teamManager;

		public bool ShowTeammateLogos
		{
			get
			{
				return _showTeammateLogos;
			}
			set
			{
				_showTeammateLogos = value;
				SetDirty();
			}
		}

		public bool ShowOpponentLogos
		{
			get
			{
				return _showOpponentLogos;
			}
			set
			{
				_showOpponentLogos = value;
				SetDirty();
			}
		}

		public void Register(TeamManager teamManager)
		{
			_teamManager = teamManager;
			teamManager.OnAssignedToTeam += OnAssignedToTeam;
			teamManager.OnRemovedFromTeam += OnRemovedFromTeam;
		}

		public void Unregister()
		{
			_teamManager.OnAssignedToTeam -= OnAssignedToTeam;
			_teamManager.OnRemovedFromTeam -= OnRemovedFromTeam;
			_teamManager = null;
		}

		public void SetDirty()
		{
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				if (!NetworkPlayerManager.TryGetPlayer((byte)playerID, out NetworkPlayer player))
				{
					continue;
				}
				Team playerTeam = TeamManager.GetPlayerTeam(playerID);
				if (playerTeam == null)
				{
					player.Icon.Texture = null;
					player.Icon.Visible = false;
					continue;
				}
				Texture logo = GetLogo(playerTeam);
				if ((Object)(object)logo == (Object)null)
				{
					player.Icon.Texture = null;
					player.Icon.Visible = false;
					continue;
				}
				bool flag = TeamManager.GetLocalTeam() == playerTeam;
				bool visible = (flag && ShowTeammateLogos) || (!flag && ShowOpponentLogos);
				player.Icon.Texture = logo;
				player.Icon.Visible = visible;
			}
		}

		private void OnAssignedToTeam(PlayerID player, Team team)
		{
			SetDirty();
		}

		private void OnRemovedFromTeam(PlayerID player, Team team)
		{
			SetDirty();
		}

		public void ClearTeams()
		{
			_teamToLogo.Clear();
			SetDirty();
		}

		public void SetLogo(Team team, Texture logo)
		{
			_teamToLogo[team] = logo;
			SetDirty();
		}

		public Texture GetLogo(Team team)
		{
			if (_teamToLogo.TryGetValue(team, out var value))
			{
				return value;
			}
			return null;
		}
	}
	public class TeamManager
	{
		private Gamemode _gamemode;

		private readonly List<Team> _teams = new List<Team>();

		private readonly Dictionary<byte, MetadataVariable> _playersToTeam = new Dictionary<byte, MetadataVariable>();

		public Gamemode Gamemode => _gamemode;

		public List<Team> Teams => _teams;

		public event Action<PlayerID, Team> OnAssignedToTeam;

		public event Action<PlayerID, Team> OnRemovedFromTeam;

		public void Register(Gamemode gamemode)
		{
			_gamemode = gamemode;
			gamemode.Metadata.OnMetadataChanged += OnMetadataChanged;
			gamemode.Metadata.OnMetadataRemoved += OnMetadataRemoved;
			MultiplayerHooking.OnPlayerLeft += OnPlayerLeft;
		}

		public void Unregister()
		{
			_gamemode.Metadata.OnMetadataChanged -= OnMetadataChanged;
			_gamemode.Metadata.OnMetadataRemoved -= OnMetadataRemoved;
			MultiplayerHooking.OnPlayerLeft -= OnPlayerLeft;
			_gamemode = null;
		}

		private void OnMetadataChanged(string key, string value)
		{
			if (!KeyHelper.KeyMatchesVariable(key, "Team"))
			{
				return;
			}
			byte playerFromKey = KeyHelper.GetPlayerFromKey(key);
			PlayerID playerID = PlayerIDManager.GetPlayerID(playerFromKey);
			MetadataVariable value2 = new MetadataVariable(key, Gamemode.Metadata);
			_playersToTeam[playerFromKey] = value2;
			foreach (Team team in Teams)
			{
				if (team.HasPlayer(playerFromKey))
				{
					if (playerID != null)
					{
						this.OnRemovedFromTeam?.InvokeSafe(playerID, team, "executing TeamManager.OnRemovedFromTeam");
					}
					team.ForceRemovePlayer(playerFromKey);
				}
			}
			Team teamByName = GetTeamByName(value);
			if (teamByName != null)
			{
				if (playerID != null)
				{
					this.OnAssignedToTeam?.InvokeSafe(playerID, teamByName, "executing TeamManager.OnAssignedToTeam");
				}
				teamByName.ForceAddPlayer(playerFromKey);
			}
		}

		private void OnMetadataRemoved(string key, string value)
		{
			if (!KeyHelper.KeyMatchesVariable(key, "Team"))
			{
				return;
			}
			byte playerFromKey = KeyHelper.GetPlayerFromKey(key);
			PlayerID playerID = PlayerIDManager.GetPlayerID(playerFromKey);
			_playersToTeam.Remove(playerFromKey);
			Team teamByName = GetTeamByName(value);
			if (teamByName != null)
			{
				if (playerID != null)
				{
					this.OnRemovedFromTeam?.InvokeSafe(playerID, teamByName, "executing TeamManager.OnRemovedFromTeam");
				}
				teamByName.ForceRemovePlayer(playerFromKey);
			}
		}

		private void OnPlayerLeft(PlayerID playerID)
		{
			byte smallID = playerID.SmallID;
			_playersToTeam.Remove(smallID);
			foreach (Team team in Teams)
			{
				if (team.HasPlayer(smallID))
				{
					this.OnRemovedFromTeam?.InvokeSafe(playerID, team, "executing TeamManager.OnRemovedFromTeam");
				}
				team.ForceRemovePlayer(smallID);
			}
		}

		public void AddTeam(Team team)
		{
			_teams.Add(team);
		}

		public void RemoveTeam(Team team)
		{
			_teams.Remove(team);
		}

		public void ClearTeams()
		{
			UnassignAllPlayers();
			Team[] array = _teams.ToArray();
			foreach (Team team in array)
			{
				RemoveTeam(team);
			}
		}

		public bool TryAssignTeam(PlayerID player, Team team)
		{
			string keyFromPlayer = KeyHelper.GetKeyFromPlayer("Team", player.SmallID);
			return Gamemode.Metadata.TrySetMetadata(keyFromPlayer, team.TeamName);
		}

		public void AssignToRandomTeams()
		{
			if (Teams.Count <= 0)
			{
				FusionLogger.Warn("Failed to assign players to random teams because there are no teams!");
				return;
			}
			List<PlayerID> list = new List<PlayerID>(PlayerIDManager.PlayerIDs);
			list.Shuffle();
			List<Team> list2 = new List<Team>(Teams);
			list2.Shuffle();
			int num = 0;
			int count = list2.Count;
			foreach (PlayerID item in list)
			{
				if (num >= count)
				{
					num = 0;
				}
				TryAssignTeam(item, list2[num++]);
			}
		}

		public void AssignToSmallestTeam(PlayerID player)
		{
			TryAssignTeam(player, GetTeamWithFewestPlayers());
		}

		public bool TryUnassignTeam(PlayerID player)
		{
			string keyFromPlayer = KeyHelper.GetKeyFromPlayer("Team", player.SmallID);
			return Gamemode.Metadata.TryRemoveMetadata(keyFromPlayer);
		}

		public void UnassignAllPlayers()
		{
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				TryUnassignTeam(playerID);
			}
		}

		public Team GetTeamByName(string name)
		{
			foreach (Team team in Teams)
			{
				if (team.TeamName == name)
				{
					return team;
				}
			}
			return null;
		}

		public Team GetPlayerTeam(PlayerID player)
		{
			if (!_playersToTeam.TryGetValue(player.SmallID, out var value))
			{
				return null;
			}
			return GetTeamByName(value.GetValue());
		}

		public Team GetLocalTeam()
		{
			return GetPlayerTeam(PlayerIDManager.LocalID);
		}

		public Team GetRandomTeam()
		{
			return Teams[Random.RandomRangeInt(0, Teams.Count)];
		}

		public Team GetTeamWithFewestPlayers()
		{
			int num = int.MaxValue;
			Team result = null;
			foreach (Team team in Teams)
			{
				if (team.PlayerCount < num)
				{
					num = team.PlayerCount;
					result = team;
				}
			}
			return result;
		}

		public bool IsTeammate(PlayerID player)
		{
			return GetLocalTeam() == GetPlayerTeam(player);
		}
	}
	public struct TeamMusic
	{
		public AudioReference WinMusic { get; set; }

		public AudioReference LoseMusic { get; set; }
	}
	public class TeamMusicManager
	{
		private readonly Dictionary<Team, TeamMusic> _teamToMusic = new Dictionary<Team, TeamMusic>();

		public AudioReference TieMusic { get; set; }

		public void ClearTeams()
		{
			_teamToMusic.Clear();
		}

		public void SetMusic(Team team, TeamMusic music)
		{
			_teamToMusic[team] = music;
		}

		public TeamMusic GetMusic(Team team)
		{
			if (_teamToMusic.TryGetValue(team, out var value))
			{
				return value;
			}
			TeamMusic teamMusic = default(TeamMusic);
			SetMusic(team, teamMusic);
			return teamMusic;
		}
	}
}
namespace LabFusion.SDK.Extenders
{
	public class AnimatorSyncerExtender : EntityComponentArrayExtender<AnimatorSyncer>
	{
		public static readonly FusionComponentCache<AnimatorSyncer, NetworkEntity> Cache = new FusionComponentCache<AnimatorSyncer, NetworkEntity>();

		protected override void OnRegister(NetworkEntity entity, AnimatorSyncer[] components)
		{
			foreach (AnimatorSyncer source in components)
			{
				Cache.Add(source, entity);
			}
			entity.OnEntityOwnershipTransfer = (NetworkEntityPlayerDelegate)Delegate.Combine(entity.OnEntityOwnershipTransfer, new NetworkEntityPlayerDelegate(OnEntityOwnershipTransfer));
			if (entity.HasOwner)
			{
				OnEntityOwnershipTransfer(entity, entity.OwnerID);
			}
		}

		protected override void OnUnregister(NetworkEntity entity, AnimatorSyncer[] components)
		{
			foreach (AnimatorSyncer source in components)
			{
				Cache.Remove(source);
			}
			entity.OnEntityOwnershipTransfer = (NetworkEntityPlayerDelegate)Delegate.Remove(entity.OnEntityOwnershipTransfer, new NetworkEntityPlayerDelegate(OnEntityOwnershipTransfer));
		}

		private void OnEntityOwnershipTransfer(NetworkEntity entity, PlayerID player)
		{
			bool isOwner = entity.IsOwner;
			AnimatorSyncer[] components = base.Components;
			foreach (AnimatorSyncer animatorSyncer in components)
			{
				try
				{
					animatorSyncer.IsOwner = isOwner;
				}
				catch (Exception e)
				{
					FusionLogger.LogException("running AnimatorSyncerExtender.OnEntityOwnershipTransfer", e);
				}
			}
		}
	}
	public class OwnershipEventsExtender : EntityComponentArrayExtender<OwnershipEvents>
	{
		protected override void OnRegister(NetworkEntity entity, OwnershipEvents[] components)
		{
			for (int i = 0; i < components.Length; i++)
			{
				components[i].Entity = entity;
			}
			entity.OnEntityOwnershipTransfer = (NetworkEntityPlayerDelegate)Delegate.Combine(entity.OnEntityOwnershipTransfer, new NetworkEntityPlayerDelegate(OnEntityOwnershipTransfer));
			if (entity.HasOwner)
			{
				OnEntityOwnershipTransfer(entity, entity.OwnerID);
			}
		}

		protected override void OnUnregister(NetworkEntity entity, OwnershipEvents[] components)
		{
			for (int i = 0; i < components.Length; i++)
			{
				components[i].Entity = null;
			}
			entity.OnEntityOwnershipTransfer = (NetworkEntityPlayerDelegate)Delegate.Remove(entity.OnEntityOwnershipTransfer, new NetworkEntityPlayerDelegate(OnEntityOwnershipTransfer));
		}

		private void OnEntityOwnershipTransfer(NetworkEntity entity, PlayerID player)
		{
			bool isOwner = entity.IsOwner;
			OwnershipEvents[] components = base.Components;
			foreach (OwnershipEvents ownershipEvents in components)
			{
				try
				{
					ownershipEvents.OnOwnerChanged(isOwner);
				}
				catch (Exception e)
				{
					FusionLogger.LogException("running OwnershipEvents", e);
				}
			}
		}
	}
	public class RPCEventExtender : EntityComponentArrayExtender<RPCEvent>
	{
		public static readonly FusionComponentCache<RPCEvent, NetworkEntity> Cache = new FusionComponentCache<RPCEvent, NetworkEntity>();

		protected override void OnRegister(NetworkEntity entity, RPCEvent[] components)
		{
			foreach (RPCEvent source in components)
			{
				Cache.Add(source, entity);
			}
		}

		protected override void OnUnregister(NetworkEntity entity, RPCEvent[] components)
		{
			foreach (RPCEvent source in components)
			{
				Cache.Remove(source);
			}
		}
	}
	public class RPCVariableExtender : EntityComponentArrayExtender<RPCVariable>
	{
		public static readonly FusionComponentCache<RPCVariable, NetworkEntity> Cache = new FusionComponentCache<RPCVariable, NetworkEntity>();

		protected override void OnRegister(NetworkEntity entity, RPCVariable[] components)
		{
			foreach (RPCVariable rPCVariable in components)
			{
				rPCVariable.HasNetworkEntity = true;
				Cache.Add(rPCVariable, entity);
			}
			entity.OnEntityDataCatchup += OnEntityDataCatchup;
		}

		protected override void OnUnregister(NetworkEntity entity, RPCVariable[] components)
		{
			foreach (RPCVariable rPCVariable in components)
			{
				rPCVariable.HasNetworkEntity = false;
				Cache.Remove(rPCVariable);
			}
			entity.OnEntityDataCatchup -= OnEntityDataCatchup;
		}

		private void OnEntityDataCatchup(NetworkEntity entity, PlayerID player)
		{
			RPCVariable[] components = base.Components;
			for (int i = 0; i < components.Length; i++)
			{
				components[i].CatchupPlayer(player);
			}
		}
	}
	public class VoiceProxyExtender : EntityComponentArrayExtender<VoiceProxy>
	{
		public static readonly FusionComponentCache<VoiceProxy, NetworkEntity> Cache = new FusionComponentCache<VoiceProxy, NetworkEntity>();

		protected override void OnRegister(NetworkEntity entity, VoiceProxy[] components)
		{
			foreach (VoiceProxy voiceProxy in components)
			{
				Cache.Add(voiceProxy, entity);
				voiceProxy.HasNetworkEntity = true;
			}
		}

		protected override void OnUnregister(NetworkEntity entity, VoiceProxy[] components)
		{
			foreach (VoiceProxy voiceProxy in components)
			{
				Cache.Remove(voiceProxy);
				voiceProxy.HasNetworkEntity = false;
			}
		}
	}
}
namespace LabFusion.SDK.Cosmetics
{
	public class CosmeticInstance
	{
		public RigManager rigManager;

		public Avatar avatar;

		public GameObject accessory;

		public Transform transform;

		public bool isHiddenInView;

		public RigPoint itemPoint;

		public Dictionary<Mirror, GameObject> mirrors = new Dictionary<Mirror, GameObject>((IEqualityComparer<Mirror>?)new UnityComparer());

		private Dictionary<RigPoint, AvatarCosmeticPoint> _avatarPoints = new Dictionary<RigPoint, AvatarCosmeticPoint>();

		private bool _destroyed;

		private bool _isPaused;

		private bool _isCulled;

		public bool IsDestroyed => _destroyed;

		public bool IsPaused
		{
			get
			{
				return _isPaused;
			}
			set
			{
				_isPaused = value;
				OnApplyVisibility();
			}
		}

		private bool IsCulled
		{
			get
			{
				return _isCulled;
			}
			set
			{
				_isCulled = value;
				OnApplyVisibility();
			}
		}

		public NetworkPlayer NetworkPlayer { get; set; }

		public CosmeticInstance(PointItemPayload payload, GameObject accessory, bool isHiddenInView, RigPoint itemPoint)
		{
			rigManager = payload.rigManager;
			avatar = null;
			this.accessory = accessory;
			transform = accessory.transform;
			this.isHiddenInView = isHiddenInView;
			this.itemPoint = itemPoint;
			if (NetworkPlayerManager.TryGetPlayer(rigManager, out var player))
			{
				NetworkPlayer = player;
			}
			OnApplyVisibility();
			Hook();
		}

		private void Hook()
		{
			rigManager.OnPostLateUpdate = ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)Action.op_Implicit((Action)OnPostLateUpdate), (Delegate)(object)rigManager.OnPostLateUpdate)).Cast<Action>();
			OpenControllerRig.OnPauseStateChange += Action<bool>.op_Implicit((Action<bool>)OnPauseStateChange);
			if (NetworkPlayer != null)
			{
				NetworkPlayer.OnHiddenChanged += OnPlayerHiddenChanged;
				IsCulled = NetworkPlayer.IsHidden;
			}
		}

		private void Unhook()
		{
			if ((Object)(object)rigManager != (Object)null)
			{
				RigManager obj = rigManager;
				obj.OnPostLateUpdate -= Action.op_Implicit((Action)OnPostLateUpdate);
				OpenControllerRig.OnPauseStateChange -= Action<bool>.op_Implicit((Action<bool>)OnPauseStateChange);
			}
			if (NetworkPlayer != null)
			{
				NetworkPlayer.OnHiddenChanged -= OnPlayerHiddenChanged;
			}
		}

		private void OnPostLateUpdate()
		{
			if (!IsDestroyed)
			{
				Update(itemPoint);
				UpdateMirrors();
			}
		}

		private void OnPauseStateChange(bool value)
		{
			if (!IsDestroyed)
			{
				IsPaused = value;
			}
		}

		private void OnPlayerHiddenChanged(bool hidden)
		{
			if (!IsDestroyed)
			{
				IsCulled = hidden;
			}
		}

		private void UpdateAvatar(Avatar avatar)
		{
			this.avatar = avatar;
			_avatarPoints = new Dictionary<RigPoint, AvatarCosmeticPoint>();
			foreach (AvatarCosmeticPoint componentsInChild in ((Component)avatar).GetComponentsInChildren<AvatarCosmeticPoint>())
			{
				RigPoint key = (RigPoint)componentsInChild.cosmeticPoint.Get();
				if (!_avatarPoints.ContainsKey(key))
				{
					_avatarPoints.Add(key, componentsInChild);
				}
			}
		}

		private void OnApplyVisibility()
		{
			if (IsCulled)
			{
				accessory.SetActive(false);
			}
			else if (!IsPaused && isHiddenInView)
			{
				accessory.SetActive(false);
			}
			else
			{
				accessory.SetActive(true);
			}
		}

		public void Update(RigPoint itemPoint)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			if (!IsCulled)
			{
				if ((Object)(object)rigManager.avatar != (Object)(object)avatar)
				{
					UpdateAvatar(rigManager.avatar);
				}
				Vector3 position;
				Quaternion rotation;
				Vector3 scale;
				if (_avatarPoints.TryGetValue(itemPoint, out var value))
				{
					CosmeticItemHelper.GetTransform(value, out position, out rotation, out scale);
				}
				else
				{
					CosmeticItemHelper.GetTransform(itemPoint, rigManager, out position, out rotation, out scale);
				}
				transform.SetPositionAndRotation(position, rotation);
				transform.localScale = scale;
			}
		}

		public void InsertMirror(Mirror mirror, GameObject accessory)
		{
			if (!mirrors.ContainsKey(mirror))
			{
				mirrors.Add(mirror, accessory);
			}
		}

		public void RemoveMirror(Mirror mirror)
		{
			if (mirrors.TryGetValue(mirror, out var value))
			{
				mirrors.Remove(mirror);
				Object.Destroy((Object)(object)value);
			}
		}

		public void UpdateMirrors()
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			List<Mirror> list = null;
			foreach (KeyValuePair<Mirror, GameObject> mirror in mirrors)
			{
				if (!Object.op_Implicit((Object)(object)mirror.Key) || !Object.op_Implicit((Object)(object)mirror.Value))
				{
					continue;
				}
				if (!((Behaviour)mirror.Key).isActiveAndEnabled)
				{
					if (list == null)
					{
						list = new List<Mirror>();
					}
					list.Add(mirror.Key);
					continue;
				}
				if ((Object)(object)mirror.Key.rigManager != (Object)(object)rigManager || IsCulled)
				{
					mirror.Value.SetActive(false);
					continue;
				}
				mirror.Value.SetActive(true);
				Transform reflectTran = mirror.Key._reflectTran;
				Transform obj = mirror.Value.transform;
				Vector3 forward = transform.forward;
				Vector3 up = transform.up;
				Vector3 forward2 = reflectTran.forward;
				Vector3 val = Vector3.Reflect(forward, forward2);
				up = Vector3.Reflect(up, forward2);
				Quaternion val2 = Quaternion.LookRotation(val, up);
				Vector3 val3 = transform.position - reflectTran.position;
				val3 = Vector3.Reflect(val3, reflectTran.forward);
				val3 += reflectTran.position;
				obj.SetPositionAndRotation(val3, val2);
				obj.localScale = transform.localScale;
			}
			if (list == null)
			{
				return;
			}
			foreach (Mirror item in list)
			{
				RemoveMirror(item);
			}
		}

		public bool IsValid()
		{
			if ((Object)(object)rigManager != (Object)null)
			{
				return (Object)(object)accessory != (Object)null;
			}
			return false;
		}

		public void Cleanup()
		{
			_destroyed = true;
			if ((Object)(object)accessory != (Object)null)
			{
				Object.Destroy((Object)(object)accessory);
			}
			foreach (KeyValuePair<Mirror, GameObject> mirror in mirrors)
			{
				if ((Object)(object)mirror.Value != (Object)null)
				{
					Object.Destroy((Object)(object)mirror.Value);
				}
			}
			mirrors.Clear();
			Unhook();
		}
	}
	public class CosmeticItem : PointItem
	{
		protected Dictionary<RigManager, CosmeticInstance> _accessoryInstances = new Dictionary<RigManager, CosmeticInstance>((IEqualityComparer<RigManager>?)new UnityComparer());

		private CosmeticVariables _variables;

		private SpawnableCrateReference _spawnableCrateReference;

		public override string Title => Variables.Title;

		public override string Description => Variables.Description;

		public override int Price => Variables.Price;

		public override string Author => Variables.Author;

		public override string Category => Variables.Category;

		public override string[] Tags => Variables.Tags;

		public override string Barcode => Variables.Barcode;

		public override bool Redacted => Variables.HiddenInShop;

		public override bool ImplementLateUpdate => true;

		public CosmeticVariables Variables => _variables;

		public CosmeticItem(CosmeticVariables variables)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			_variables = variables;
			_spawnableCrateReference = new SpawnableCrateReference(variables.Barcode);
		}

		public override void LoadPreviewIcon(Action<Texture2D> onLoaded)
		{
			SpawnableCrate crate = ((CrateReferenceT<SpawnableCrate>)(object)_spawnableCrateReference).Crate;
			if ((Object)(object)crate == (Object)null)
			{
				return;
			}
			Action<GameObject> action = delegate(GameObject go)
			{
				CosmeticRoot component = go.GetComponent<CosmeticRoot>();
				if (!((Object)(object)component == (Object)null))
				{
					Texture2D obj = component.previewIcon.Get();
					onLoaded(obj);
				}
			};
			((MarrowAssetT<GameObject>)(object)((GameObjectCrate)crate).MainGameObject).LoadAsset(Action<GameObject>.op_Implicit(action));
		}

		public override void OnUpdateObjects(PointItemPayload payload, bool isVisible)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (isVisible && (Object)(object)((CrateReferenceT<SpawnableCrate>)(object)_spawnableCrateReference).Crate == (Object)null)
			{
				return;
			}
			if (payload.type == PointItemPayloadType.MIRROR)
			{
				if (!_accessoryInstances.ContainsKey(payload.rigManager))
				{
					return;
				}
				if (isVisible)
				{
					Transform tempParent = new GameObject("Temp Parent").transform;
					((Component)tempParent).gameObject.SetActive(false);
					Action<GameObject> action = delegate(GameObject go)
					{
						GameObject val2 = Object.Instantiate<GameObject>(go, tempParent);
						val2.SetActive(false);
						val2.transform.parent = null;
						Object.Destroy((Object)(object)((Component)tempParent).gameObject);
						((Object)val2).name = ((Object)go).name + " (Mirror)";
						_accessoryInstances[payload.rigManager].InsertMirror(payload.mirror, val2);
					};
					((MarrowAssetT<GameObject>)(object)((GameObjectCrate)((CrateReferenceT<SpawnableCrate>)(object)_spawnableCrateReference).Crate).MainGameObject).LoadAsset(Action<GameObject>.op_Implicit(action));
				}
				else
				{
					_accessoryInstances[payload.rigManager].RemoveMirror(payload.mirror);
				}
			}
			else
			{
				if ((Object)(object)payload.rigManager == (Object)null)
				{
					return;
				}
				if (isVisible && !_accessoryInstances.ContainsKey(payload.rigManager))
				{
					Action<GameObject> action2 = delegate(GameObject go)
					{
						GameObject val = Object.Instantiate<GameObject>(go);
						((Object)val).name = ((Object)go).name;
						CosmeticInstance value = new CosmeticInstance(payload, val, payload.type == PointItemPayloadType.SELF && Variables.HiddenInView, Variables.CosmeticPoint);
						_accessoryInstances.Add(payload.rigManager, value);
					};
					((MarrowAssetT<GameObject>)(object)((GameObjectCrate)((CrateReferenceT<SpawnableCrate>)(object)_spawnableCrateReference).Crate).MainGameObject).LoadAsset(Action<GameObject>.op_Implicit(action2));
				}
				else if (!isVisible && _accessoryInstances.ContainsKey(payload.rigManager))
				{
					_accessoryInstances[payload.rigManager].Cleanup();
					_accessoryInstances.Remove(payload.rigManager);
				}
			}
		}

		public override void OnLateUpdate()
		{
			if (_accessoryInstances.Count <= 0)
			{
				return;
			}
			List<CosmeticInstance> list = null;
			foreach (KeyValuePair<RigManager, CosmeticInstance> accessoryInstance in _accessoryInstances)
			{
				if (!accessoryInstance.Value.IsValid())
				{
					if (list == null)
					{
						list = new List<CosmeticInstance>();
					}
					list.Add(accessoryInstance.Value);
				}
			}
			if (list != null)
			{
				for (int i = 0; i < list.Count; i++)
				{
					CosmeticInstance cosmeticInstance = list[i];
					cosmeticInstance.Cleanup();
					_accessoryInstances.Remove(cosmeticInstance.rigManager);
				}
			}
		}
	}
	public enum CosmeticScaleMode
	{
		NONE,
		HEIGHT,
		HEAD
	}
	public static class CosmeticItemHelper
	{
		private static Vector3 GetEyeCenter(ArtRig artRig)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			return (artRig.eyeLf.position + artRig.eyeRt.position) * 0.5f;
		}

		public static CosmeticScaleMode GetScaleMode(RigPoint point)
		{
			if ((uint)point > 5u)
			{
				_ = point - 6;
				_ = 3;
				return CosmeticScaleMode.HEIGHT;
			}
			return CosmeticScaleMode.HEAD;
		}

		public static void GetTransform(AvatarCosmeticPoint point, out Vector3 position, out Quaternion rotation, out Vector3 scale)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)point).transform;
			position = transform.position;
			rotation = transform.rotation;
			scale = transform.lossyScale;
		}

		public static void GetTransform(RigPoint itemPoint, RigManager rig, out Vector3 position, out Quaternion rotation, out Vector3 scale)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			PhysicsRig physicsRig = rig.physicsRig;
			ArtRig artOutput = physicsRig.artOutput;
			Avatar avatar = rig._avatar;
			scale = GetScale(avatar, GetScaleMode(itemPoint));
			Transform head = ((Rig)physicsRig).m_head;
			switch (itemPoint)
			{
			default:
				position = head.position;
				rotation = head.rotation;
				break;
			case RigPoint.HEAD_TOP:
			{
				Vector3 eyeCenter2 = GetEyeCenter(artOutput);
				eyeCenter2 += head.up * (avatar.HeadTop * avatar.height);
				eyeCenter2 -= head.forward * (avatar.ForeheadEllipseZ * avatar.height * 0.5f);
				eyeCenter2 = head.InverseTransformPoint(eyeCenter2);
				position = head.position;
				position = head.InverseTransformPoint(position);
				position.y = eyeCenter2.y;
				position = head.TransformPoint(position);
				rotation = head.rotation;
				break;
			}
			case RigPoint.EYE_LEFT:
				position = artOutput.eyeLf.position;
				rotation = artOutput.eyeLf.rotation;
				break;
			case RigPoint.EYE_CENTER:
				position = GetEyeCenter(artOutput);
				rotation = head.rotation;
				break;
			case RigPoint.NOSE:
			{
				Vector3 eyeCenter = GetEyeCenter(artOutput);
				position = head.position + head.forward * (avatar.ForeheadEllipseZ * avatar.height);
				eyeCenter = head.InverseTransformPoint(eyeCenter);
				position = head.InverseTransformPoint(position);
				position.y = eyeCenter.y;
				position = head.TransformPoint(position);
				rotation = head.rotation;
				break;
			}
			case RigPoint.EYE_RIGHT:
				position = artOutput.eyeRt.position;
				rotation = artOutput.eyeRt.rotation;
				break;
			case RigPoint.CHEST:
				position = ((Rig)physicsRig).m_chest.position;
				rotation = ((Rig)physicsRig).m_chest.rotation;
				break;
			case RigPoint.CHEST_BACK:
			{
				Transform chest = ((Rig)physicsRig).m_chest;
				position = chest.position - chest.forward * avatar.ChestEllipseNegZ;
				rotation = chest.rotation;
				break;
			}
			case RigPoint.HIPS:
				position = ((Rig)physicsRig).m_pelvis.position;
				rotation = ((Rig)physicsRig).m_pelvis.rotation;
				break;
			case RigPoint.LOCOSPHERE:
			{
				Transform transform = ((Component)rig.physicsRig.physG).transform;
				position = transform.position;
				rotation = transform.rotation;
				break;
			}
			}
		}

		public static Vector3 GetScale(Avatar avatar, CosmeticScaleMode mode)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			return (Vector3)(mode switch
			{
				CosmeticScaleMode.HEIGHT => Vector3Extensions.one * (avatar.height / 1.76f), 
				CosmeticScaleMode.HEAD => Vector3Extensions.one * (avatar.ForeheadEllipseX / 0.044f * avatar.height) / 1.76f, 
				_ => Vector3Extensions.one, 
			});
		}
	}
	public static class CosmeticLoader
	{
		public static readonly string[] RequiredTags = new string[2] { "Fusion", "Cosmetic" };

		public static void OnAssetWarehouseReady()
		{
			LoadAllCosmetics();
			Action<Barcode> action = OnPalletAdded;
			AssetWarehouse instance = AssetWarehouse.Instance;
			instance.OnPalletAdded += Action<Barcode>.op_Implicit(action);
		}

		private static void OnPalletAdded(Barcode barcode)
		{
			Pallet pallet = default(Pallet);
			if (AssetWarehouse.Instance.TryGetPallet(barcode, ref pallet))
			{
				LoadAllCosmetics(CrateFilterer.FilterByTags<SpawnableCrate>(pallet, RequiredTags));
			}
		}

		public static void LoadAllCosmetics()
		{
			LoadAllCosmetics(CrateFilterer.FilterByTags<SpawnableCrate>(RequiredTags));
		}

		public static void LoadAllCosmetics(SpawnableCrate[] crates)
		{
			foreach (SpawnableCrate crate in crates)
			{
				Action<GameObject> action = delegate(GameObject go)
				{
					OnCrateAssetLoaded(go, crate);
				};
				((MarrowAssetT<GameObject>)(object)((GameObjectCrate)crate).MainGameObject).LoadAsset(Action<GameObject>.op_Implicit(action));
			}
		}

		private static void OnCrateAssetLoaded(GameObject gameObject, SpawnableCrate crate)
		{
			if (PointItemManager.TryGetPointItem(((Scannable)crate).Barcode.ID, out var _))
			{
				return;
			}
			CosmeticRoot component = gameObject.GetComponent<CosmeticRoot>();
			if (!((Object)(object)component == (Object)null))
			{
				string title = ((Scannable)crate).Title;
				string description = ((Scannable)crate).Description;
				Barcode barcode = ((Scannable)crate).Barcode;
				List<string> list = ((IEnumerable<string>)((Crate)crate).Tags.ToArray()).ToList();
				list.RemoveAll((string t) => RequiredTags.Contains(t));
				string author = ((Crate)crate).Pallet.Author;
				string title2 = ((Scannable)((Crate)crate).Pallet).Title;
				RigPoint cosmeticPoint = (RigPoint)component.cosmeticPoint.Get();
				int price = component.rawPrice.Get();
				bool hiddenInView = component.hiddenInView.Get();
				bool hiddenInShop = component.hiddenInShop.Get();
				CosmeticVariables variables = default(CosmeticVariables);
				variables.Title = title;
				variables.Description = description;
				variables.Author = author;
				variables.Category = title2;
				variables.Tags = list.ToArray();
				variables.Barcode = barcode.ID;
				variables.CosmeticPoint = cosmeticPoint;
				variables.Price = price;
				variables.HiddenInView = hiddenInView;
				variables.HiddenInShop = hiddenInShop;
				PointItemManager.RegisterPointItem(new CosmeticItem(variables));
			}
		}
	}
	public struct CosmeticVariables
	{
		public string Title;

		public string Description;

		public string Author;

		public string Category;

		public string[] Tags;

		public string Barcode;

		public int Price;

		public RigPoint CosmeticPoint;

		public bool HiddenInView;

		public bool HiddenInShop;
	}
}
namespace LabFusion.SDK.Achievements
{
	public abstract class Achievement : IXMLPackable
	{
		public abstract string Title { get; }

		public abstract string Description { get; }

		public abstract int BitReward { get; }

		public virtual string Progress => $"{CompletedTasks} out of {MaxTasks} Tasks Completed";

		public virtual string Barcode => Title + ".Achievement";

		public virtual Texture Logo => MenuResources.GetAchievementIcon(Title);

		public bool IsComplete => CompletedTasks >= MaxTasks;

		public virtual bool Redacted => false;

		public int CompletedTasks { get; protected set; }

		public virtual int MaxTasks => 1;

		public static event Action<Achievement> OnAchievementUpdated;

		public static event Action<Achievement> OnAchievementCompleted;

		public void Register()
		{
			OnRegister();
		}

		protected virtual void OnRegister()
		{
		}

		public void Unregister()
		{
			OnUnregister();
		}

		protected virtual void OnUnregister()
		{
		}

		public virtual void Pack(XElement element)
		{
			element.SetAttributeValue("CompletedTasks", CompletedTasks);
		}

		public virtual void Unpack(XElement element)
		{
			if (element.TryGetAttribute("CompletedTasks", out var value) && int.TryParse(value, out var result))
			{
				CompletedTasks = result;
			}
		}

		public virtual void IncrementTask()
		{
			if (!IsComplete)
			{
				CompletedTasks++;
				if (IsComplete)
				{
					Complete();
				}
				Achievement.OnAchievementUpdated?.Invoke(this);
			}
		}

		private void Complete()
		{
			PointItemManager.RewardBits(BitReward);
			Achievement.OnAchievementCompleted?.Invoke(this);
			OnComplete();
		}

		protected virtual void OnComplete()
		{
		}
	}
	public static class AchievementManager
	{
		internal static readonly List<Achievement> Achievements = new List<Achievement>();

		internal static readonly Dictionary<string, Achievement> AchievementLookup = new Dictionary<string, Achievement>();

		public static IReadOnlyList<Achievement> LoadedAchievements => Achievements;

		public static void LoadAchievements(Assembly assembly)
		{
			if (assembly == null)
			{
				throw new NullReferenceException("Tried loading achievements from a null assembly!");
			}
			AssemblyUtilities.LoadAllValid<Achievement>(assembly, RegisterAchievement);
		}

		public static void RegisterAchievement<T>() where T : Achievement
		{
			RegisterAchievement(typeof(T));
		}

		private static void RegisterAchievement(Type type)
		{
			Achievement achievement = Activator.CreateInstance(type) as Achievement;
			if (AchievementLookup.ContainsKey(achievement.Barcode))
			{
				throw new ArgumentException("Achievement with barcode " + achievement.Barcode + " was already registered.");
			}
			Achievements.Add(achievement);
			AchievementLookup.Add(achievement.Barcode, achievement);
			if (AchievementSaveManager.Pointers.TryGetValue(achievement.Barcode, out var value))
			{
				achievement.Unpack(XElement.Parse(value.Data));
			}
			achievement.Register();
		}

		public static bool TryGetAchievement(string barcode, out Achievement achievement)
		{
			if (barcode == null)
			{
				achievement = null;
				return false;
			}
			return AchievementLookup.TryGetValue(barcode, out achievement);
		}

		public static bool TryGetAchievement<T>(out T achievement) where T : Achievement
		{
			foreach (Achievement achievement2 in Achievements)
			{
				if (achievement2 is T val)
				{
					achievement = val;
					return true;
				}
			}
			achievement = null;
			return false;
		}

		public static void IncrementAchievements<T>() where T : Achievement
		{
			foreach (T achievement in GetAchievements<T>())
			{
				achievement.IncrementTask();
			}
		}

		public static List<T> GetAchievements<T>() where T : Achievement
		{
			List<T> list = new List<T>();
			foreach (Achievement achievement in Achievements)
			{
				if (achievement is T item)
				{
					list.Add(item);
				}
			}
			return list;
		}

		public static void CheckCompletionistUnlocks()
		{
			if (IsCompleted())
			{
				PointSaveManager.UnlockItem(((ScannableReference)FusionSpawnableReferences.VictoryTrophyReference).Barcode.ID);
			}
		}

		public static bool IsCompleted()
		{
			return GetAchievementProgress() >= 1f;
		}

		public static float GetAchievementProgress()
		{
			int num = 0;
			int num2 = 0;
			foreach (Achievement loadedAchievement in LoadedAchievements)
			{
				if (!loadedAchievement.Redacted)
				{
					if (loadedAchievement.IsComplete)
					{
						num2++;
					}
					num++;
				}
			}
			return ManagedMathf.Clamp01((float)num2 / (float)num);
		}

		public static IReadOnlyList<Achievement> GetSortedAchievements()
		{
			List<Achievement> list = (from a in LoadedAchievements
				orderby a.IsComplete, a.BitReward
				select a).ToList();
			list.RemoveAll((Achievement a) => a.Redacted && !a.IsComplete);
			return list;
		}
	}
	public static class AchievementSaveManager
	{
		[Serializable]
		public class AchievementPointer : IXMLPackable
		{
			[JsonPropertyName("data")]
			public string Data { get; set; }

			public AchievementPointer(Achievement achievement)
			{
				XElement xElement = new XElement("Data");
				achievement.Pack(xElement);
				Data = xElement.ToString();
			}

			public AchievementPointer()
			{
			}

			public void Pack(XElement element)
			{
				element.SetAttributeValue("Data", Data);
			}

			public void Unpack(XElement element)
			{
				element.TryGetAttribute("Data", out var value);
				Data = value;
			}
		}

		[Serializable]
		public class AchievementSaveData
		{
			[JsonPropertyName("pointers")]
			public Dictionary<string, AchievementPointer> Pointers { get; set; }

			public static AchievementSaveData CreateCurrent()
			{
				return new AchievementSaveData
				{
					Pointers = _achievementPointers
				};
			}
		}

		private const string _filePath = "achievements.dat";

		private const string _backupPath = "achievements.dat.bak";

		private static Dictionary<string, AchievementPointer> _achievementPointers = new Dictionary<string, AchievementPointer>();

		public static Dictionary<string, AchievementPointer> Pointers => _achievementPointers;

		public static void OnInitializeMelon()
		{
			Achievement.OnAchievementUpdated += SaveAchievement;
		}

		public static void WriteToFile()
		{
			DataSaver.WriteJsonToFile("achievements.dat", AchievementSaveData.CreateCurrent());
		}

		public static void WriteBackup()
		{
			string path = PersistentData.GetPath("achievements.dat");
			string path2 = PersistentData.GetPath("achievements.dat.bak");
			if (File.Exists(path))
			{
				File.Copy(path, path2, overwrite: true);
			}
		}

		public static void ReadFile()
		{
			AchievementSaveData achievementSaveData = DataSaver.ReadJsonFromFile<AchievementSaveData>("achievements.dat");
			if (achievementSaveData != null && achievementSaveData.Pointers != null)
			{
				_achievementPointers = achievementSaveData.Pointers;
			}
		}

		public static void SaveAchievement(Achievement achievement)
		{
			if (!_achievementPointers.ContainsKey(achievement.Barcode))
			{
				_achievementPointers.Add(achievement.Barcode, null);
			}
			_achievementPointers[achievement.Barcode] = new AchievementPointer(achievement);
			WriteToFile();
		}
	}
	public class AroundTheWorld : Achievement
	{
		private readonly List<string> _levels = new List<string>();

		public override string Title => "Around The World";

		public override string Description => "Play 10 different levels in one multiplayer session.";

		public override int BitReward => 700;

		protected override void OnRegister()
		{
			MultiplayerHooking.OnMainSceneInitialized += OnMainSceneInitialized;
			MultiplayerHooking.OnDisconnected += OnDisconnect;
		}

		protected override void OnUnregister()
		{
			MultiplayerHooking.OnMainSceneInitialized -= OnMainSceneInitialized;
			MultiplayerHooking.OnDisconnected -= OnDisconnect;
		}

		private void OnMainSceneInitialized()
		{
			if (NetworkInfo.HasServer && PlayerIDManager.HasOtherPlayers && !_levels.Contains(FusionSceneManager.Barcode))
			{
				_levels.Add(FusionSceneManager.Barcode);
				if (_levels.Count >= 10)
				{
					IncrementTask();
					_levels.Clear();
				}
			}
		}

		private void OnDisconnect()
		{
			_levels.Clear();
		}
	}
	public abstract class StyleAchievement : Achievement
	{
		protected override void OnRegister()
		{
			CheckTasks();
			PointItemManager.OnItemUnlocked += OnItemUnlocked;
		}

		protected override void OnUnregister()
		{
			PointItemManager.OnItemUnlocked -= OnItemUnlocked;
		}

		private void OnItemUnlocked(PointItem item)
		{
			CheckTasks();
		}

		private void CheckTasks()
		{
			if (base.IsComplete)
			{
				return;
			}
			int num = PointItemManager.GetUnlockedItems().Count - base.CompletedTasks;
			if (num > 0)
			{
				for (int i = 0; i < num; i++)
				{
					IncrementTask();
				}
			}
		}
	}
	public class StyleAddict : StyleAchievement
	{
		public override string Title => "Style Addict";

		public override string Description => "Purchase your twentieth cosmetic.";

		public override int BitReward => 5000;

		public override int MaxTasks => 20;
	}
	public class StyleBaby : StyleAchievement
	{
		public override string Title => "Style Baby";

		public override string Description => "Purchase your first cosmetic.";

		public override int BitReward => 50;

		public override int MaxTasks => 1;
	}
	public class StyleMan : StyleAchievement
	{
		public override string Title => "Style Man";

		public override string Description => "Purchase your tenth cosmetic.";

		public override int BitReward => 1000;

		public override int MaxTasks => 10;
	}
	public class ClassStruggle : Achievement
	{
		public override string Title => "Class Struggle";

		public override string Description => "Get constrained by the server host.";

		public override int BitReward => 700;
	}
	public class CleanupCrew : Achievement
	{
		public override string Title => "Cleanup Crew";

		public override string Description => "Despawn 1000 things across servers.";

		public override int BitReward => 1000;

		public override int MaxTasks => 1000;
	}
	public class DaycareAttendant : Achievement
	{
		protected float _timeElapsed;

		protected bool _oneHourPassed;

		public override string Title => "Daycare Attendant";

		public override string Description => "Stay in the same server for one hour.";

		public override int BitReward => 500;

		protected override void OnRegister()
		{
			MultiplayerHooking.OnJoinedServer += OnJoinServer;
			MultiplayerHooking.OnStartedServer += OnJoinServer;
			MultiplayerHooking.OnDisconnected += OnDisconnect;
		}

		protected override void OnUnregister()
		{
			MultiplayerHooking.OnJoinedServer -= OnJoinServer;
			MultiplayerHooking.OnStartedServer -= OnJoinServer;
			MultiplayerHooking.OnDisconnected -= OnDisconnect;
			MultiplayerHooking.OnLateUpdate -= OnLateUpdate;
		}

		private void OnJoinServer()
		{
			_timeElapsed = 0f;
			_oneHourPassed = false;
			MultiplayerHooking.OnLateUpdate += OnLateUpdate;
		}

		private void OnDisconnect()
		{
			_timeElapsed = 0f;
			_oneHourPassed = false;
			MultiplayerHooking.OnLateUpdate -= OnLateUpdate;
		}

		private void OnLateUpdate()
		{
			if (!_oneHourPassed && PlayerIDManager.HasOtherPlayers)
			{
				_timeElapsed += TimeReferences.DeltaTime;
				if (_timeElapsed >= 3600f)
				{
					_oneHourPassed = true;
					IncrementTask();
				}
			}
		}
	}
	public class ExperiencedExecutioner : KillerAchievement
	{
		public override string Title => "Experienced Executioner";

		public override string Description => "Kill 100 players in Deathmatch or Team Deathmatch.";

		public override int BitReward => 200;

		public override int MaxTasks => 100;
	}
	public abstract class KillerAchievement : Achievement
	{
	}
	public class MediocreMarksman : KillerAchievement
	{
		public override string Title => "Mediocre Marksman";

		public override string Description => "Kill 10 players in Deathmatch or Team Deathmatch.";

		public override int BitReward => 50;

		public override int MaxTasks => 10;
	}
	public class Rampage : Achievement
	{
		public override string Title => "Rampage";

		public override string Description => "Win a Deathmatch match without dying a single time.";

		public override int BitReward => 1500;
	}
	public class RookieAssassin : KillerAchievement
	{
		public override string Title => "Rookie Assassin";

		public override string Description => "Kill your first player in Deathmatch or Team Deathmatch.";

		public override int BitReward => 10;
	}
	public class GuardianAngel : Achievement
	{
		public override string Title => "Guardian Angel";

		public override string Description => "Save another person from dying.";

		public override int BitReward => 500;

		protected override void OnRegister()
		{
			MultiplayerHooking.OnPlayerAction += OnPlayerAction;
		}

		protected override void OnUnregister()
		{
			MultiplayerHooking.OnPlayerAction -= OnPlayerAction;
		}

		private void OnPlayerAction(PlayerID player, PlayerActionType type, PlayerID otherPlayer)
		{
			if (!player.IsMe && type == PlayerActionType.RECOVERY && PuppetMasterExtender.LastKilled != null && PuppetMasterExtender.LastKilled.IsOwner)
			{
				IncrementTask();
			}
		}
	}
	public class HeadOfHouse : Achievement
	{
		public override string Title => "Head Of House";

		public override string Description => "Start a server.";

		public override int BitReward => 50;
	}
	public class HelloThere : Achievement
	{
		public override string Title => "Hello There";

		public override string Description => "Discover the secret in the Information Box.";

		public override int BitReward => 10;
	}
	public class HighwayMan : Achievement
	{
		public override string Title => "Highway Man";

		public override string Description => "Grab something out of someone's holster.";

		public override int BitReward => 150;
	}
	public class LavaGang : Achievement
	{
		public override string Title => "Lava Gang";

		public override string Description => "Spawn 1000 things across servers.";

		public override int BitReward => 1000;

		public override int MaxTasks => 1000;
	}
	public class WarmWelcome : Achievement
	{
		public override string Title => "Warm Welcome";

		public override string Description => "Join a server.";

		public override int BitReward => 50;
	}
}
namespace LabFusion.Scene
{
	public static class FusionSceneManager
	{
		private static Action _onTargetLevelLoad = null;

		private static Action _onLevelLoad = null;

		private static Action _onDelayedLevelLoad = null;

		private static bool _isLoading = true;

		private static bool _wasLoading = true;

		private static string _prevLevelBarcode = "NONE";

		public const float LEVEL_LOAD_WINDOW = 0.5f;

		private static bool _isDelayedLoading = true;

		private static float _loadingTimer = 0f;

		private static string _targetServerScene = string.Empty;

		private static string _targetServerLoadScene = string.Empty;

		private static bool _hasStartedLoadingTarget = false;

		private static bool _hasEnteredTargetLoadingScreen = false;

		private static bool _hasStartedDownloadingTarget = false;

		public static LevelCrate Level => SceneStreamer.Session.Level;

		public static string Barcode
		{
			get
			{
				if (!((Object)(object)Level != (Object)null))
				{
					return "";
				}
				return ((Scannable)Level).Barcode.ID;
			}
		}

		public static string Title
		{
			get
			{
				if (!((Object)(object)Level != (Object)null))
				{
					return "";
				}
				return ((Scannable)Level).Title;
			}
		}

		public static LevelCrate LoadLevel => SceneStreamer.Session.LoadLevel;

		public static string LoadBarcode
		{
			get
			{
				if (!((Object)(object)LoadLevel != (Object)null))
				{
					return "";
				}
				return ((Scannable)LoadLevel).Barcode.ID;
			}
		}

		public static void HookOnTargetLevelLoad(Action action)
		{
			if (!HasTargetLoaded())
			{
				_onTargetLevelLoad = (Action)Delegate.Combine(_onTargetLevelLoad, action);
			}
			else
			{
				action?.Invoke();
			}
		}

		public static void HookOnLevelLoad(Action action)
		{
			if (IsLoading())
			{
				_onLevelLoad = (Action)Delegate.Combine(_onLevelLoad, action);
			}
			else
			{
				action?.Invoke();
			}
		}

		public static void HookOnDelayedLevelLoad(Action action)
		{
			if (IsDelayedLoading())
			{
				_onDelayedLevelLoad = (Action)Delegate.Combine(_onDelayedLevelLoad, action);
			}
			else
			{
				action?.Invoke();
			}
		}

		internal static void Internal_OnInitializeMelon()
		{
			MultiplayerHooking.OnStartedServer += Internal_OnCleanup;
			MultiplayerHooking.OnDisconnected += Internal_OnCleanup;
			LevelDownloaderManager.OnInitializeMelon();
		}

		private static void Internal_OnCleanup()
		{
			_targetServerScene = string.Empty;
			_targetServerLoadScene = string.Empty;
			_hasStartedLoadingTarget = false;
			_hasEnteredTargetLoadingScreen = false;
			_hasStartedDownloadingTarget = false;
		}

		private static void Internal_SetServerScene(string barcode, string loadBarcode)
		{
			_hasStartedDownloadingTarget = false;
			_targetServerScene = barcode;
			_targetServerLoadScene = loadBarcode;
			_hasStartedLoadingTarget = false;
			_hasEnteredTargetLoadingScreen = false;
		}

		private static void Internal_UpdateLoadStatus()
		{
			if (IsLoading_Internal())
			{
				_prevLevelBarcode = null;
				_isLoading = true;
				if (!_wasLoading)
				{
					LoadSender.SendLoadingState(isLoading: true);
					LocalPlayer.Metadata.LevelBarcode.SetValue(Barcode);
					if (NetworkInfo.IsHost)
					{
						LoadSender.SendLevelLoad(Barcode, LoadBarcode);
					}
					MultiplayerHooking.InvokeOnLoadingBegin();
				}
			}
			else if (_prevLevelBarcode == null)
			{
				_isLoading = false;
				FusionMod.OnMainSceneInitialized();
				_prevLevelBarcode = Barcode;
				LoadSender.SendLoadingState(!HasTargetLoaded());
				LocalPlayer.Metadata.LevelBarcode.SetValue(Barcode);
				_onLevelLoad?.InvokeSafe("executing OnLevelLoad hook");
				_onLevelLoad = null;
				if (HasTargetLoaded())
				{
					_onTargetLevelLoad?.InvokeSafe("executing OnTargetLevelLoad hook");
					_onTargetLevelLoad = null;
					MultiplayerHooking.InvokeTargetLevelLoaded();
				}
			}
			_wasLoading = _isLoading;
		}

		private static void Internal_UpdateDelayedLoadStatus()
		{
			if (_isLoading)
			{
				_loadingTimer = 0f;
				_isDelayedLoading = true;
			}
			else if (_loadingTimer <= 0.5f)
			{
				_loadingTimer += TimeReferences.DeltaTime;
				_isDelayedLoading = true;
			}
			else if (_isDelayedLoading)
			{
				_isDelayedLoading = false;
				FusionMod.OnMainSceneInitializeDelayed();
				_onDelayedLevelLoad?.InvokeSafe("executing OnDelayedLevelLoad hook");
				_onDelayedLevelLoad = null;
			}
		}

		private static void Internal_UpdateTargetScene()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			if (!NetworkInfo.IsClient)
			{
				return;
			}
			if (_hasStartedLoadingTarget && IsLoading())
			{
				_hasEnteredTargetLoadingScreen = true;
			}
			if (IsDelayedLoadDone() && !_hasStartedDownloadingTarget && !_hasStartedLoadingTarget && !string.IsNullOrEmpty(_targetServerScene))
			{
				if (CrateFilterer.HasCrate<LevelCrate>(new Barcode(_targetServerScene)))
				{
					LoadTargetScene();
				}
				else if (ClientSettings.Downloading.DownloadLevels.Value)
				{
					LevelDownloaderManager.LevelDownloadInfo info = default(LevelDownloaderManager.LevelDownloadInfo);
					info.LevelBarcode = _targetServerScene;
					info.LevelHost = 0;
					info.OnDownloadSucceeded = OnDownloadSucceeded;
					info.OnDownloadFailed = OnDownloadFailed;
					info.OnDownloadCanceled = OnDownloadCanceled;
					LevelDownloaderManager.DownloadLevel(info);
					_hasStartedDownloadingTarget = true;
				}
				else
				{
					OnDownloadFailed();
				}
			}
		}

		private static void OnDownloadSucceeded()
		{
			HookOnDelayedLevelLoad(LoadTargetScene);
			_hasStartedDownloadingTarget = false;
		}

		private static void OnDownloadFailed()
		{
			NetworkHelper.Disconnect("The server's level failed to install!");
			_hasStartedDownloadingTarget = false;
		}

		private static void OnDownloadCanceled()
		{
			_hasStartedDownloadingTarget = false;
		}

		public static void LoadTargetScene()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_001f: Expected O, but got Unknown
			SceneStreamerPatches.IgnorePatches = true;
			SceneStreamer.Load(new Barcode(_targetServerScene), new Barcode(_targetServerLoadScene));
			SceneStreamerPatches.IgnorePatches = false;
			_hasStartedLoadingTarget = true;
		}

		internal static void Internal_UpdateScene()
		{
			Internal_UpdateLoadStatus();
			Internal_UpdateDelayedLoadStatus();
			Internal_UpdateTargetScene();
		}

		public static void SetTargetScene(string barcode, string loadBarcode)
		{
			Internal_SetServerScene(barcode, loadBarcode);
		}

		public static bool IsLoading()
		{
			return _isLoading;
		}

		public static bool IsDelayedLoading()
		{
			return _isDelayedLoading;
		}

		public static bool IsLoadDone()
		{
			return !_isLoading;
		}

		public static bool IsDelayedLoadDone()
		{
			return !_isDelayedLoading;
		}

		public static bool HasTargetLoaded()
		{
			if (!NetworkInfo.HasServer || NetworkInfo.IsHost)
			{
				return IsLoadDone();
			}
			if (_hasStartedLoadingTarget && _hasEnteredTargetLoadingScreen)
			{
				return IsLoadDone();
			}
			return false;
		}

		private static bool IsLoading_Internal()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			return (int)SceneStreamer.Session.Status == 1;
		}
	}
	public static class LevelDownloaderManager
	{
		public struct LevelDownloadInfo
		{
			public string LevelBarcode;

			public byte LevelHost;

			public Action OnDownloadSucceeded;

			public Action OnDownloadFailed;

			public Action OnDownloadCanceled;
		}

		private static bool _initializedDownloadUI = false;

		private static bool _downloadingLevel = false;

		private static ModIOFile _downloadingFile = new ModIOFile(-1);

		private static string _downloadingBarcode = null;

		private static LevelDownloadInfo _downloadingInfo;

		public static void OnInitializeMelon()
		{
			MultiplayerHooking.OnUpdate += OnUpdate;
			MultiplayerHooking.OnDisconnected += OnDisconnect;
		}

		private static void OnDisconnect()
		{
			NetworkSceneManager.Purgatory = false;
		}

		public static void DownloadLevel(LevelDownloadInfo info)
		{
			_downloadingBarcode = info.LevelBarcode;
			_downloadingInfo = info;
			long value = DataConversions.ConvertMegabytesToBytes(ClientSettings.Downloading.MaxLevelSize.Value);
			NetworkModRequester.ModInstallInfo installInfo = default(NetworkModRequester.ModInstallInfo);
			installInfo.Target = info.LevelHost;
			installInfo.Barcode = info.LevelBarcode;
			installInfo.BeginDownloadCallback = OnDownloadBegin;
			installInfo.FinishDownloadCallback = OnDownloadFinished;
			installInfo.MaxBytes = value;
			installInfo.HighPriority = true;
			NetworkModRequester.RequestAndInstallMod(installInfo);
		}

		private static void OnDownloadBegin(NetworkModRequester.ModCallbackInfo info)
		{
			_initializedDownloadUI = false;
			_downloadingLevel = true;
			_downloadingFile = info.ModFile;
			NetworkSceneManager.Purgatory = true;
			LoadWaitingScene();
		}

		private static void OnDownloadFinished(DownloadCallbackInfo info)
		{
			NetworkSceneManager.Purgatory = false;
			_downloadingLevel = false;
			_downloadingFile = new ModIOFile(-1);
			if (info.Result == ModResult.CANCELED)
			{
				_downloadingInfo.OnDownloadCanceled?.Invoke();
			}
			else if (info.Result == ModResult.FAILED)
			{
				_downloadingInfo.OnDownloadFailed?.Invoke();
			}
			else
			{
				_downloadingInfo.OnDownloadSucceeded?.Invoke();
			}
		}

		private static void LoadWaitingScene()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			SceneStreamerPatches.IgnorePatches = true;
			SceneStreamer.Load(new Barcode(((ScannableReference)FusionLevelReferences.LoadDownloadingReference).Barcode), (Barcode)null);
			SceneStreamerPatches.IgnorePatches = false;
		}

		private static void OnUpdate()
		{
			if (!_downloadingLevel || ModIODownloader.CurrentTransaction == null)
			{
				return;
			}
			float progress = ModIODownloader.CurrentTransaction.Progress;
			LevelDownloadUI instance = LevelDownloadUI.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				if (!_initializedDownloadUI)
				{
					MenuButtonHelper.PopulateTexts(((Component)instance).gameObject);
					instance.LevelTitleText.text = "DOWNLOADING " + _downloadingBarcode;
					SetUIIcon(instance);
					_initializedDownloadUI = true;
				}
				instance.ProgressBarSlider.value = progress;
				instance.ProgressBarText.text = $"{progress * 100f}%";
				if (progress >= 1f)
				{
					instance.LevelTitleText.text = "DOWNLOAD COMPLETE";
				}
			}
		}

		private static void SetUIIcon(LevelDownloadUI ui)
		{
			Texture levelIcon = MenuResources.GetLevelIcon("Mods");
			ui.LevelIcon.texture = levelIcon;
			if (_downloadingFile.ModID != -1)
			{
				ModIOThumbnailDownloader.GetThumbnail(_downloadingFile.ModID, delegate(Texture texture)
				{
					ui.LevelIcon.texture = texture;
				});
			}
		}
	}
	public static class NetworkSceneManager
	{
		private static bool _purgatory;

		private static bool _allPlayersLoaded;

		public static bool Purgatory
		{
			get
			{
				return _purgatory;
			}
			set
			{
				if (value != _purgatory)
				{
					_purgatory = value;
					NetworkSceneManager.OnPurgatoryChanged?.Invoke(value);
				}
			}
		}

		public static bool IsLevelHost => NetworkInfo.IsHost;

		public static bool IsLevelNetworked
		{
			get
			{
				if (NetworkInfo.HasServer)
				{
					return !Purgatory;
				}
				return false;
			}
		}

		public static event Action<bool> OnPurgatoryChanged;

		public static event Action OnAllPlayersLoaded;

		public static event Action<PlayerID, string> OnPlayerLoadedIntoLevel;

		public static event Action<PlayerID> OnPlayerStartedLoading;

		internal static void OnInitializeMelon()
		{
			PlayerID.OnMetadataChangedEvent += OnMetadataChangedCallback;
			MultiplayerHooking.OnPlayerLeft += OnPlayerLeft;
			MultiplayerHooking.OnMainSceneInitialized += OnMainSceneInitialized;
		}

		private static void OnMainSceneInitialized()
		{
			_allPlayersLoaded = false;
			CheckAllPlayersLoaded();
		}

		private static void OnPlayerLeft(PlayerID playerId)
		{
			CheckAllPlayersLoaded();
		}

		private static void OnMetadataChangedCallback(PlayerID playerId, string key, string value)
		{
			if (key == playerId.Metadata.Loading.Key)
			{
				bool value2 = playerId.Metadata.Loading.GetValue();
				string value3 = playerId.Metadata.LevelBarcode.GetValue();
				if (!value2)
				{
					NetworkSceneManager.OnPlayerLoadedIntoLevel?.InvokeSafe(playerId, value3, "executing OnPlayerLoadedIntoLevel");
					CheckAllPlayersLoaded();
				}
				else
				{
					NetworkSceneManager.OnPlayerStartedLoading?.InvokeSafe(playerId, "executing OnPlayerStartedLoading");
				}
			}
		}

		private static void CheckAllPlayersLoaded()
		{
			if (_allPlayersLoaded)
			{
				return;
			}
			foreach (PlayerID item in GetPlayersInCurrentLevel())
			{
				if (item.Metadata.Loading.GetValue())
				{
					return;
				}
			}
			_allPlayersLoaded = true;
			NetworkSceneManager.OnAllPlayersLoaded?.InvokeSafe("executing OnAllPlayersLoaded");
		}

		public static bool InCurrentLevel(PlayerID player)
		{
			if (player.IsMe)
			{
				return true;
			}
			if (!IsLevelNetworked)
			{
				return false;
			}
			return InLevel(player, FusionSceneManager.Barcode);
		}

		public static bool InLevel(PlayerID player, string barcode)
		{
			return GetLevelBarcode(player) == barcode;
		}

		public static string GetLevelBarcode(PlayerID player)
		{
			return player.Metadata.LevelBarcode.GetValue();
		}

		public static PlayerID GetLevelHost(string barcode)
		{
			return PlayerIDManager.GetHostID();
		}

		public static bool PlayerIsLevelHost(PlayerID player)
		{
			return player == PlayerIDManager.GetHostID();
		}

		public static List<PlayerID> GetPlayersInLevel(string barcode)
		{
			List<PlayerID> list = new List<PlayerID>(PlayerIDManager.PlayerIDs.Count);
			if (!IsLevelNetworked)
			{
				return list;
			}
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				if (InLevel(playerID, barcode))
				{
					list.Add(playerID);
				}
			}
			return list;
		}

		public static List<PlayerID> GetPlayersInCurrentLevel()
		{
			return GetPlayersInLevel(FusionSceneManager.Barcode);
		}
	}
	public static class NetworkTransformManager
	{
		public const float WorldLimit = 50000f;

		public const float WorldLimitSquared = 2.5E+09f;

		public const float SpeedLimit = 1000f;

		public static Vector3 FloatingOrigin { get; set; } = Vector3Extensions.zero;


		public static Vector3 EncodePosition(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return position - FloatingOrigin;
		}

		public static Vector3 DecodePosition(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return position + FloatingOrigin;
		}

		public static bool IsInBounds(Vector3 position)
		{
			if (float.IsNaN(((Vector3)(ref position)).sqrMagnitude))
			{
				return false;
			}
			if (((Vector3)(ref position)).sqrMagnitude >= 2.5E+09f)
			{
				return false;
			}
			return true;
		}

		public static Vector3 LimitVelocity(Vector3 velocity)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return Vector3.ClampMagnitude(velocity, 1000f);
		}
	}
}
namespace LabFusion.Safety
{
	public static class FilterSettings
	{
		public const char CensorCharacter = '*';

		public static string CensorString(int length)
		{
			return new string('*', length);
		}
	}
	public static class LinkFilter
	{
		public const string LinkExpression = "[-a-zA-Z0-9@:%._\\+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}\\b([-a-zA-Z0-9()@:%_\\+.~#?&\\\\=]*)";

		public static string Filter(string text)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return Regex.Replace(text, "[-a-zA-Z0-9@:%._\\+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}\\b([-a-zA-Z0-9()@:%_\\+.~#?&\\\\=]*)", (Match match) => FilterSettings.CensorString(match.Length));
		}
	}
	public static class ProfanityFilter
	{
		public static string Filter(string text)
		{
			if (!ClientSettings.Safety.FilterProfanity.Value)
			{
				return text;
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			if (ContainsProfanity(text))
			{
				return FilterSettings.CensorString(text.Length);
			}
			return text;
		}

		public static bool ContainsProfanity(string text)
		{
			if (!ClientSettings.Safety.FilterProfanity.Value)
			{
				return false;
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			string text2 = text.ToLower();
			foreach (string word in ProfanityListManager.List.Words)
			{
				if (text2.Contains(word.ToLower()))
				{
					return true;
				}
			}
			return false;
		}
	}
	public static class TextFilter
	{
		public const string NonAlphanumericExpression = "[^a-zA-Z0-9]";

		public static string FilterCommonAndRichText(string text)
		{
			return ApplyCommonFilters(text.RemoveRichText());
		}

		public static string FilterCommon(string text)
		{
			return ApplyCommonFilters(text.RemoveRichTextExceptColor());
		}

		private static string ApplyCommonFilters(string text)
		{
			return LinkFilter.Filter(ProfanityFilter.Filter(text));
		}

		public static string RemoveNonAlphanumeric(string text)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return Regex.Replace(text, "[^a-zA-Z0-9]", string.Empty);
		}

		public static string SanitizeName(string name)
		{
			return RemoveNonAlphanumeric(name.RemoveRichText());
		}
	}
	[Serializable]
	public class GlobalBanInfo
	{
		[JsonPropertyName("username")]
		public string Username { get; set; }

		[JsonPropertyName("reason")]
		public string Reason { get; set; }

		[JsonPropertyName("games")]
		public List<LabFusion.Data.GameInfo> Games { get; set; } = new List<LabFusion.Data.GameInfo>();


		[JsonPropertyName("platforms")]
		public List<PlatformInfo> Platforms { get; set; } = new List<PlatformInfo>();

	}
	[Serializable]
	public class GlobalBanList
	{
		[JsonPropertyName("bans")]
		public List<GlobalBanInfo> Bans { get; set; } = new List<GlobalBanInfo>();

	}
	public static class GlobalBanManager
	{
		public const string FileName = "globalBans.json";

		public static GlobalBanList List { get; private set; } = new GlobalBanList();


		public static void FetchFile()
		{
			ListFetcher.FetchFile("globalBans.json", OnFileFetched);
		}

		private static void OnFileFetched(string text)
		{
			List = DataSaver.ReadJsonFromText<GlobalBanList>(text);
		}

		public static void ExportFile()
		{
			DataSaver.WriteJsonToFile("globalBans.json", List);
		}

		public static void ExportBan(PlayerInfo playerInfo, string reason)
		{
			LabFusion.Data.GameInfo item = new LabFusion.Data.GameInfo
			{
				Game = Application.productName
			};
			List<LabFusion.Data.GameInfo> games = new List<LabFusion.Data.GameInfo> { item };
			PlatformInfo platform = new PlatformInfo(playerInfo.PlatformID);
			List<PlatformInfo> platforms = new List<PlatformInfo> { platform };
			GlobalBanInfo item2 = new GlobalBanInfo
			{
				Username = playerInfo.Username,
				Reason = reason,
				Games = games,
				Platforms = platforms
			};
			List.Bans.RemoveAll((GlobalBanInfo info) => info.Platforms.Contains(platform));
			List.Bans.Add(item2);
			ExportFile();
		}

		public static void ExportPardon(PlatformInfo platform)
		{
			List.Bans.RemoveAll((GlobalBanInfo info) => info.Platforms.Contains(platform));
			ExportFile();
		}

		public static bool IsBanned(PlatformInfo platform)
		{
			return List.Bans.Any((GlobalBanInfo info) => info.Platforms.Contains(platform));
		}

		public static GlobalBanInfo GetBanInfo(PlatformInfo platform)
		{
			foreach (GlobalBanInfo ban in List.Bans)
			{
				if (ban.Platforms.Contains(platform))
				{
					return ban;
				}
			}
			return null;
		}

		public static bool IsBanned(LobbyInfo lobby)
		{
			if (lobby.Privacy == ServerPrivacy.FRIENDS_ONLY)
			{
				return false;
			}
			if (IsBanned(new PlatformInfo(lobby.LobbyID)))
			{
				return true;
			}
			PlayerInfo[] players = lobby.PlayerList.Players;
			for (int i = 0; i < players.Length; i++)
			{
				if (IsBanned(new PlatformInfo(players[i].PlatformID)))
				{
					return true;
				}
			}
			return false;
		}
	}
	[Serializable]
	public class GlobalModBlacklist
	{
		[JsonPropertyName("mods")]
		public List<ModInfo> Mods { get; set; } = new List<ModInfo>();

	}
	public static class GlobalModBlacklistManager
	{
		public const string FileName = "globalModBlacklist.json";

		public static GlobalModBlacklist List { get; private set; } = new GlobalModBlacklist();


		public static bool BlacklistEnabled => LobbyInfoManager.LobbyInfo.Privacy == ServerPrivacy.PUBLIC;

		public static void FetchFile()
		{
			ListFetcher.FetchFile("globalModBlacklist.json", OnFileFetched);
		}

		private static void OnFileFetched(string text)
		{
			List = DataSaver.ReadJsonFromText<GlobalModBlacklist>(text);
		}

		public static void ExportFile()
		{
			DataSaver.WriteJsonToFile("globalModBlacklist.json", List);
		}

		public static bool IsBarcodeBlacklisted(string barcode)
		{
			if (!BlacklistEnabled)
			{
				return false;
			}
			return List.Mods.Any((ModInfo m) => m.Barcodes.Contains(barcode));
		}

		public static bool IsModIDBlacklisted(int modID)
		{
			if (!BlacklistEnabled)
			{
				return false;
			}
			return List.Mods.Any((ModInfo m) => m.ModID != -1 && m.ModID == modID);
		}

		public static bool IsNameIDBlacklisted(string nameID)
		{
			if (!BlacklistEnabled)
			{
				return false;
			}
			return List.Mods.Any((ModInfo m) => !string.IsNullOrWhiteSpace(m.NameID) && m.NameID == nameID);
		}
	}
	public static class ListFetcher
	{
		[CompilerGenerated]
		private sealed class <CoFetchFile>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string url;

			public Action<string> callback;

			private HttpClient <client>5__2;

			private Task<HttpResponseMessage> <responseTask>5__3;

			private Task<string> <stringTask>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <CoFetchFile>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<client>5__2 = null;
				<responseTask>5__3 = null;
				<stringTask>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
					{
						<>1__state = -1;
						HttpClientHandler handler = new HttpClientHandler
						{
							ClientCertificateOptions = ClientCertificateOption.Automatic,
							ServerCertificateCustomValidationCallback = (HttpRequestMessage _, X509Certificate2? _, X509Chain? _, SslPolicyErrors _) => true
						};
						<client>5__2 = new HttpClient(handler);
						<>1__state = -3;
						<responseTask>5__3 = <client>5__2.GetAsync(url, HttpCompletionOption.ResponseContentRead);
						goto IL_00a4;
					}
					case 1:
						<>1__state = -3;
						goto IL_00a4;
					case 2:
						{
							<>1__state = -3;
							goto IL_0181;
						}
						IL_0181:
						if (<stringTask>5__4.IsCompleted)
						{
							if (!<stringTask>5__4.IsCompletedSuccessfully)
							{
								FusionLogger.LogException("reading string content from " + url, <stringTask>5__4.Exception);
								result = false;
								break;
							}
							FusionLogger.Log("ListFetcher - Finished fetching " + url + "!", ConsoleColor.DarkGreen);
							string result2 = <stringTask>5__4.Result;
							callback?.Invoke(result2);
							result = false;
							break;
						}
						<>2__current = null;
						<>1__state = 2;
						result = true;
						goto end_IL_0000;
						IL_00a4:
						if (<responseTask>5__3.IsCompleted)
						{
							if (!<responseTask>5__3.IsCompletedSuccessfully)
							{
								FusionLogger.LogException("fetching list from " + url, <responseTask>5__3.Exception);
								result = false;
								break;
							}
							HttpResponseMessage result3 = <responseTask>5__3.Result;
							if (result3.StatusCode != HttpStatusCode.OK)
							{
								FusionLogger.Warn($"Failed to fetch {url} with code: {result3.StatusCode}");
								result = false;
								break;
							}
							HttpContent content = result3.Content;
							<stringTask>5__4 = content.ReadAsStringAsync();
							goto IL_0181;
						}
						<>2__current = null;
						<>1__state = 1;
						result = true;
						goto end_IL_0000;
					}
					<>m__Finally1();
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<client>5__2 != null)
				{
					((IDisposable)<client>5__2).Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public const string LogPrefix = "ListFetcher -";

		public const string RepositoryURL = "https://raw.githubusercontent.com/Lakatrazz/Fusion-Lists/main/";

		public const string Branch = "main";

		public static void FetchFile(string path, Action<string> callback)
		{
			string text = "https://raw.githubusercontent.com/Lakatrazz/Fusion-Lists/main/" + path;
			FusionLogger.Log($"{"ListFetcher -"} Fetching {path} from url {text}...", ConsoleColor.DarkGreen);
			MelonCoroutines.Start(CoFetchFile(text, callback));
		}

		[IteratorStateMachine(typeof(<CoFetchFile>d__4))]
		private static IEnumerator CoFetchFile(string url, Action<string> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoFetchFile>d__4(0)
			{
				url = url,
				callback = callback
			};
		}
	}
	public static class ListLoader
	{
		internal static void OnInitializeMelon()
		{
			GlobalBanManager.FetchFile();
			ProfanityListManager.FetchFile();
			GlobalModBlacklistManager.FetchFile();
			URLWhitelistManager.FetchFile();
		}
	}
	[Serializable]
	public class ProfanityList
	{
		[JsonPropertyName("words")]
		public List<string> Words { get; set; } = new List<string>();

	}
	public static class ProfanityListManager
	{
		public const string FileName = "profanityList.json";

		public static ProfanityList List { get; private set; } = new ProfanityList();


		public static void FetchFile()
		{
			ListFetcher.FetchFile("profanityList.json", OnFileFetched);
		}

		private static void OnFileFetched(string text)
		{
			List = DataSaver.ReadJsonFromText<ProfanityList>(text);
		}

		public static void ExportFile()
		{
			DataSaver.WriteJsonToFile("profanityList.json", List);
		}

		public static void ExportWord(string word)
		{
			List.Words.Add(word);
			ExportFile();
		}
	}
	public enum TrustedStatus
	{
		None,
		Impersonator,
		Trusted,
		Master
	}
	public static class TrustedListManager
	{
		public struct TrustedPlayer
		{
			public ulong ID;

			public string Name;

			public bool Unique;

			public TrustedPlayer(ulong id, string name, bool unique = true)
			{
				ID = id;
				Name = name;
				Unique = unique;
			}
		}

		private static readonly TrustedPlayer[] _steamPlayers = new TrustedPlayer[9]
		{
			new TrustedPlayer(76561198198752494uL, "Lakatrazz"),
			new TrustedPlayer(76561198097630377uL, "AlexTheBaBa"),
			new TrustedPlayer(76561198222917852uL, "Mr.Gaming"),
			new TrustedPlayer(76561198096586464uL, "brwok"),
			new TrustedPlayer(76561198143565238uL, "Riggle"),
			new TrustedPlayer(76561198233973112uL, "Alfie", unique: false),
			new TrustedPlayer(76561198061847729uL, "zz0000"),
			new TrustedPlayer(76561198837064193uL, "172", unique: false),
			new TrustedPlayer(76561198147092613uL, "Eli", unique: false)
		};

		public static TrustedStatus VerifyPlayer(ulong id, string name)
		{
			if (NetworkLayerManager.Layer is SteamNetworkLayer)
			{
				return VerifyPlayer(_steamPlayers, id, name);
			}
			return TrustedStatus.None;
		}

		private static TrustedStatus VerifyPlayer(TrustedPlayer[] players, ulong id, string name)
		{
			for (int i = 0; i < players.Length; i++)
			{
				TrustedPlayer trustedPlayer = players[i];
				if (trustedPlayer.ID == id)
				{
					return TrustedStatus.Master;
				}
				string value = TextFilter.SanitizeName(trustedPlayer.Name).ToLower();
				if (TextFilter.SanitizeName(name).ToLower().Contains(value) && trustedPlayer.Unique)
				{
					return TrustedStatus.Impersonator;
				}
			}
			return TrustedStatus.None;
		}
	}
	[Serializable]
	public class URLInfo
	{
		[JsonPropertyName("domain")]
		public string Domain { get; set; }
	}
	[Serializable]
	public class URLWhitelist
	{
		[JsonPropertyName("whitelist")]
		public List<URLInfo> Whitelist { get; set; } = new List<URLInfo>();

	}
	public static class URLWhitelistManager
	{
		public const string FileName = "urlWhitelist.json";

		public static URLWhitelist List { get; private set; } = new URLWhitelist();


		public static void FetchFile()
		{
			ListFetcher.FetchFile("urlWhitelist.json", OnFileFetched);
		}

		private static void OnFileFetched(string text)
		{
			List = DataSaver.ReadJsonFromText<URLWhitelist>(text);
		}

		public static bool IsURLWhitelisted(string url)
		{
			if (!Uri.TryCreate(url, UriKind.Absolute, out Uri result))
			{
				return true;
			}
			if (!(result.Scheme == Uri.UriSchemeHttp) && !(result.Scheme == Uri.UriSchemeHttps))
			{
				return true;
			}
			string host = result.Host;
			foreach (URLInfo item in List.Whitelist)
			{
				if (host == item.Domain)
				{
					return true;
				}
			}
			return false;
		}
	}
	public static class LimitedActivityManager
	{
		public static Dictionary<string, LimitedActivityTracker> IDToTrackerLookup { get; } = new Dictionary<string, LimitedActivityTracker>();


		public static LimitedActivityTracker GetTracker(string id, float activityPeriod = 1f)
		{
			if (IDToTrackerLookup.TryGetValue(id, out var value))
			{
				value.ActivityPeriod = activityPeriod;
				return value;
			}
			LimitedActivityTracker limitedActivityTracker = new LimitedActivityTracker(activityPeriod);
			IDToTrackerLookup[id] = limitedActivityTracker;
			return limitedActivityTracker;
		}
	}
	public class LimitedActivityTracker
	{
		public class Activity
		{
			private int _counter;

			public int Counter
			{
				get
				{
					if (PastActivityPeriod)
					{
						return 0;
					}
					return _counter;
				}
			}

			public float LastActivityTime { get; private set; }

			public float TimeSinceActivity => TimeReferences.TimeSinceStartup - LastActivityTime;

			public float ActivityPeriod { get; set; } = 1f;


			public bool PastActivityPeriod => TimeSinceActivity >= ActivityPeriod;

			public void Increment()
			{
				if (PastActivityPeriod)
				{
					_counter = 0;
					LastActivityTime = TimeReferences.TimeSinceStartup;
				}
				_counter++;
			}

			public void Reset()
			{
				LastActivityTime = 0f;
				_counter = 0;
			}
		}

		private float _activityPeriod = 1f;

		public Dictionary<int, Activity> IDToActivityLookup { get; } = new Dictionary<int, Activity>();


		public float ActivityPeriod
		{
			get
			{
				return _activityPeriod;
			}
			set
			{
				if (_activityPeriod == value)
				{
					return;
				}
				_activityPeriod = value;
				foreach (Activity value2 in IDToActivityLookup.Values)
				{
					value2.ActivityPeriod = value;
				}
			}
		}

		public LimitedActivityTracker()
			: this(1f)
		{
		}

		public LimitedActivityTracker(float activityPeriod)
		{
			_activityPeriod = activityPeriod;
		}

		public Activity GetActivity(int id)
		{
			if (IDToActivityLookup.TryGetValue(id, out var value))
			{
				return value;
			}
			Activity activity = new Activity
			{
				ActivityPeriod = _activityPeriod
			};
			IDToActivityLookup[id] = activity;
			return activity;
		}

		public void Increment(int id)
		{
			GetActivity(id).Increment();
		}

		public void Clear()
		{
			IDToActivityLookup.Clear();
		}
	}
}
namespace LabFusion.Safety.Patching
{
	[HarmonyPatch(typeof(VideoPlayer))]
	public static class VideoPlayerPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("Prepare")]
		public static bool PreparePrefix(VideoPlayer __instance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if ((int)__instance.source == 1 && !URLWhitelistManager.IsURLWhitelisted(__instance.url))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("url")]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static void SetUrlPrefix(ref string value)
		{
			if (NetworkSceneManager.IsLevelNetworked && !URLWhitelistManager.IsURLWhitelisted(value))
			{
				value = string.Empty;
			}
		}
	}
}
namespace LabFusion.RPC
{
	public static class NetworkAssetSpawner
	{
		public struct SpawnCallbackInfo
		{
			public GameObject Spawned;

			public NetworkEntity Entity;
		}

		public struct SpawnRequestInfo
		{
			public Spawnable Spawnable;

			public Vector3 Position;

			public Quaternion Rotation;

			public Action<SpawnCallbackInfo> SpawnCallback;

			public bool SpawnEffect;

			public EntitySource SpawnSource;
		}

		public struct DespawnRequestInfo
		{
			public ushort EntityID;

			public bool DespawnEffect;
		}

		private static uint _lastTrackedSpawnable = 0u;

		private static readonly Dictionary<uint, Action<SpawnCallbackInfo>> _callbackQueue = new Dictionary<uint, Action<SpawnCallbackInfo>>();

		public static void OnSpawnComplete(uint trackerId, SpawnCallbackInfo info)
		{
			if (_callbackQueue.TryGetValue(trackerId, out var value))
			{
				value(info);
				_callbackQueue.Remove(trackerId);
			}
		}

		public static void Spawn(SpawnRequestInfo info)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			uint num = _lastTrackedSpawnable++;
			if (info.SpawnCallback != null)
			{
				_callbackQueue.Add(num, info.SpawnCallback);
			}
			MessageRelay.RelayNative(new SerializedSpawnData
			{
				Barcode = ((ScannableReference)info.Spawnable.crateRef).Barcode.ID,
				SerializedTransform = new SerializedTransform(info.Position, info.Rotation),
				SpawnEffect = info.SpawnEffect,
				TrackerID = num,
				SpawnSource = info.SpawnSource
			}, NativeMessageTag.SpawnRequest, CommonMessageRoutes.ReliableToServer);
		}

		public static void Despawn(DespawnRequestInfo info)
		{
			MessageRelay.RelayNative(new DespawnRequestData
			{
				Entity = new NetworkEntityReference(info.EntityID),
				DespawnEffect = info.DespawnEffect
			}, NativeMessageTag.DespawnRequest, CommonMessageRoutes.ReliableToServer);
		}
	}
	public static class NetworkModRequester
	{
		public struct ModCallbackInfo
		{
			public ModIOFile ModFile;

			public bool HasFile;

			public string Platform;
		}

		public struct ModRequestInfo
		{
			public byte Target;

			public string Barcode;

			public Action<ModCallbackInfo> ModCallback;
		}

		public struct ModInstallInfo
		{
			public byte Target;

			public string Barcode;

			public Action<ModCallbackInfo> BeginDownloadCallback;

			public DownloadCallback FinishDownloadCallback;

			public long? MaxBytes;

			public IProgress<float> Reporter;

			public bool HighPriority;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass7_0
		{
			public bool receivedCallback;

			public ModInstallInfo installInfo;
		}

		[CompilerGenerated]
		private sealed class <WaitAndInstallMod>d__7 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ModInstallInfo installInfo;

			private <>c__DisplayClass7_0 <>8__1;

			private float <elapsed>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WaitAndInstallMod>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass7_0();
					<>8__1.installInfo = installInfo;
					<elapsed>5__2 = 0f;
					<>8__1.receivedCallback = false;
					ModRequestInfo info2 = default(ModRequestInfo);
					info2.Target = <>8__1.installInfo.Target;
					info2.Barcode = <>8__1.installInfo.Barcode;
					info2.ModCallback = OnModInfoReceived;
					RequestMod(info2);
					break;
				}
				case 1:
					<>1__state = -1;
					break;
				}
				if (!<>8__1.receivedCallback && <elapsed>5__2 < 5f)
				{
					<elapsed>5__2 += TimeReferences.DeltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if (!<>8__1.receivedCallback)
				{
					<>8__1.installInfo.FinishDownloadCallback?.Invoke(DownloadCallbackInfo.FailedCallback);
					<>8__1.installInfo.BeginDownloadCallback = null;
					<>8__1.installInfo.FinishDownloadCallback = null;
				}
				return false;
				void OnModInfoReceived(ModCallbackInfo info)
				{
					((<>c__DisplayClass7_0)this).receivedCallback = true;
					if (!info.HasFile)
					{
						((<>c__DisplayClass7_0)this).installInfo.FinishDownloadCallback?.Invoke(DownloadCallbackInfo.FailedCallback);
					}
					else
					{
						((<>c__DisplayClass7_0)this).installInfo.BeginDownloadCallback?.Invoke(info);
						bool temporary = !ClientSettings.Downloading.KeepDownloadedMods.Value;
						if (((<>c__DisplayClass7_0)this).installInfo.HighPriority)
						{
							ModIODownloader.CancelQueue();
						}
						ModIODownloader.EnqueueDownload(new ModTransaction
						{
							ModFile = info.ModFile,
							Temporary = temporary,
							Callback = ((<>c__DisplayClass7_0)this).installInfo.FinishDownloadCallback,
							MaxBytes = ((<>c__DisplayClass7_0)this).installInfo.MaxBytes,
							Reporter = ((<>c__DisplayClass7_0)this).installInfo.Reporter
						});
					}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static uint _lastTrackedRequest = 0u;

		private static readonly Dictionary<uint, Action<ModCallbackInfo>> _callbackQueue = new Dictionary<uint, Action<ModCallbackInfo>>();

		public static void OnResponseReceived(uint trackerId, ModCallbackInfo info)
		{
			if (_callbackQueue.TryGetValue(trackerId, out var value))
			{
				value(info);
				_callbackQueue.Remove(trackerId);
			}
		}

		public static void RequestAndInstallMod(ModInstallInfo installInfo)
		{
			MelonCoroutines.Start(WaitAndInstallMod(installInfo));
		}

		[IteratorStateMachine(typeof(<WaitAndInstallMod>d__7))]
		private static IEnumerator WaitAndInstallMod(ModInstallInfo installInfo)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitAndInstallMod>d__7(0)
			{
				installInfo = installInfo
			};
		}

		public static void RequestMod(ModRequestInfo info)
		{
			uint num = _lastTrackedRequest++;
			if (info.ModCallback != null)
			{
				_callbackQueue.Add(num, info.ModCallback);
			}
			MessageRelay.RelayNative(new ModInfoRequestData
			{
				Barcode = info.Barcode,
				TrackerID = num
			}, NativeMessageTag.ModInfoRequest, new MessageRoute(info.Target, NetworkChannel.Reliable));
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	public class RpcAttribute : Attribute
	{
		public RelayType RelayType = RelayType.ToClients;

		public NetworkChannel Channel;

		private long _methodHash;

		public long MethodHash => _methodHash;

		public RpcAttribute()
		{
		}

		public RpcAttribute(RelayType relayType)
		{
			RelayType = relayType;
		}

		public void SetHash(long hash)
		{
			_methodHash = hash;
		}
	}
	public static class RpcManager
	{
		public static Harmony HarmonyInstance { get; private set; }

		public static Dictionary<long, MethodBase> HashToMethod { get; private set; } = new Dictionary<long, MethodBase>();


		public static Dictionary<MethodBase, long> MethodToHash { get; private set; } = new Dictionary<MethodBase, long>();


		public static Dictionary<MethodBase, RpcAttribute> MethodToRpc { get; private set; } = new Dictionary<MethodBase, RpcAttribute>();


		public static bool InvokingRpc { get; set; } = false;


		public static void OnInitialize()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			HarmonyInstance = new Harmony("com.fusion.rpc");
		}

		public static void LoadRpcs(Assembly assembly)
		{
			if (!assembly.IsValid())
			{
				FusionLogger.Error("Assembly " + assembly.FullName + " is invalid and rpcs will not be loaded.");
				return;
			}
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				if (type.IsValid())
				{
					MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					for (int j = 0; j < methods.Length; j++)
					{
						LoadRpc(methods[j]);
					}
				}
			}
		}

		public static void LoadRpc(MethodInfo method)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			RpcAttribute customAttribute = method.GetCustomAttribute<RpcAttribute>();
			if (customAttribute != null)
			{
				string? fullName = method.DeclaringType.FullName;
				long num = BitMath.MakeLong(right: method.GetNameWithParameters().GetDeterministicHashCode(), left: fullName.GetDeterministicHashCode());
				customAttribute.SetHash(num);
				HashToMethod[num] = method;
				MethodToHash[method] = num;
				MethodToRpc[method] = customAttribute;
				HarmonyInstance.Patch((MethodBase)method, new HarmonyMethod(typeof(RpcManager).GetMethod("StaticRpcPrefix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static bool StaticRpcPrefix(object[] __args, MethodBase __originalMethod)
		{
			if (InvokingRpc)
			{
				InvokingRpc = false;
				return true;
			}
			if (!NetworkInfo.HasServer)
			{
				return false;
			}
			if (!MethodToRpc.TryGetValue(__originalMethod, out var value))
			{
				return false;
			}
			MessageRelay.RelayNative(new RPCMethodData
			{
				MethodHash = value.MethodHash,
				Parameters = __args
			}, NativeMessageTag.RPCMethod, new MessageRoute(value.RelayType, value.Channel));
			return false;
		}

		public static void InvokeMethod(RPCMethodData data)
		{
			if (!HashToMethod.TryGetValue(data.MethodHash, out var value))
			{
				return;
			}
			InvokingRpc = true;
			try
			{
				value.Invoke(null, data.Parameters);
			}
			catch (Exception e)
			{
				FusionLogger.LogException($"invoking Rpc {data.MethodHash} named {value.Name}", e);
			}
		}
	}
}
namespace LabFusion.Representation
{
	public enum PermissionLevel : sbyte
	{
		GUEST = -1,
		DEFAULT,
		OPERATOR,
		OWNER
	}
	public static class FusionPermissions
	{
		public static void OnInitializeMelon()
		{
			LocalPlayer.Metadata.PermissionLevel.SetValue(PermissionLevel.DEFAULT.ToString());
			LocalPlayer.OnApplyInitialMetadata += OnUpdateInitialMetadata;
		}

		private static void OnUpdateInitialMetadata()
		{
			string value = (NetworkInfo.IsHost ? PermissionLevel.OWNER.ToString() : PermissionLevel.DEFAULT.ToString());
			LocalPlayer.Metadata.PermissionLevel.SetValue(value);
		}

		public static void FetchPermissionLevel(ulong longId, out PermissionLevel level, out Color color)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			level = PermissionLevel.DEFAULT;
			color = Color.white;
			if (NetworkInfo.IsHost)
			{
				if (longId != PlayerIDManager.LocalPlatformID)
				{
					foreach (Tuple<ulong, string, PermissionLevel> permittedUser in PermissionList.PermittedUsers)
					{
						if (permittedUser.Item1 == longId)
						{
							level = permittedUser.Item3;
						}
					}
					return;
				}
				level = PermissionLevel.OWNER;
			}
			else
			{
				PlayerID playerID = PlayerIDManager.GetPlayerID(longId);
				if (playerID != null)
				{
					Enum.TryParse<PermissionLevel>(playerID.Metadata.PermissionLevel.GetValue(), out level);
				}
			}
		}

		public static void TrySetPermission(ulong longId, string username, PermissionLevel level)
		{
			PermissionList.SetPermission(longId, username, level);
			PlayerID playerID = PlayerIDManager.GetPlayerID(longId);
			if (playerID != null && NetworkInfo.IsHost)
			{
				playerID.Metadata.PermissionLevel.SetValue(level.ToString());
			}
		}

		public static bool HasSufficientPermissions(PermissionLevel level, PermissionLevel requirement)
		{
			return level >= requirement;
		}

		public static bool HasHigherPermissions(PermissionLevel level, PermissionLevel requirement)
		{
			return level > requirement;
		}
	}
	public static class PlayerRepUtilities
	{
		public const string PlayerRepName = "[RigManager (Networked)]";

		public static bool TryGetReferences(byte smallId, out RigRefs references)
		{
			references = null;
			if (NetworkPlayerManager.TryGetPlayer(smallId, out var player))
			{
				references = player.RigRefs;
				return true;
			}
			return false;
		}

		public static void CreateNewRig(Action<RigManager> onRigCreated)
		{
			if ((Object)(object)MarrowSettings.RuntimeInstance == (Object)null)
			{
				return;
			}
			SpawnableCrate crate = ((CrateReferenceT<SpawnableCrate>)(object)MarrowSettings.RuntimeInstance.DefaultPlayerRig).Crate;
			if (!((Object)(object)crate == (Object)null))
			{
				((CrateT<GameObject>)(object)crate).LoadAsset(Action<GameObject>.op_Implicit((Action<GameObject>)delegate(GameObject go)
				{
					Internal_OnLoadPlayer(go, onRigCreated);
				}));
			}
		}

		private static void Internal_OnLoadPlayer(GameObject asset, Action<RigManager> onRigCreated)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject();
			val.SetActive(false);
			GameObject val2 = Object.Instantiate<GameObject>(((Component)asset.GetComponentInChildren<RigManager>()).gameObject, val.transform);
			((Object)val2).name = "[RigManager (Networked)]";
			val2.SetActive(false);
			if (Object.op_Implicit((Object)(object)RigData.Refs.RigManager))
			{
				val2.transform.position = RigData.RigSpawn;
				val2.transform.rotation = RigData.RigSpawnRot;
			}
			RigManager component = val2.GetComponent<RigManager>();
			Internal_SetupPlayerRep(component);
			val2.transform.parent = null;
			Object.Destroy((Object)(object)val);
			val2.SetActive(true);
			onRigCreated?.Invoke(component);
		}

		private static void Internal_SetupPlayerRep(RigManager rigManager)
		{
			((Component)rigManager).gameObject.AddComponent<AntiHasher>();
			OpenControllerRig val = ((Il2CppObjectBase)rigManager.ControllerRig).TryCast<OpenControllerRig>();
			MarrowEntity marrowEntity = rigManager.physicsRig.marrowEntity;
			marrowEntity.Tags.Tags.RemoveAll(Predicate<BoneTagReference>.op_Implicit((Func<BoneTagReference, bool>)((BoneTagReference tag) => ((ScannableReference)tag).Barcode == ((ScannableReference)MarrowBoneTagReferences.PlayerReference).Barcode)));
			marrowEntity.Tags.Tags.Add(FusionBoneTagReferences.FusionPlayerReference);
			MarrowEntity component = ((Component)val).GetComponent<MarrowEntity>();
			Il2CppArrayBase<MarrowBody> componentsInChildren = ((Component)val).GetComponentsInChildren<MarrowBody>();
			Il2CppArrayBase<Tracker> componentsInChildren2 = ((Component)val).GetComponentsInChildren<Tracker>();
			foreach (MarrowBody item in componentsInChildren)
			{
				Object.DestroyImmediate((Object)(object)item);
			}
			foreach (Tracker item2 in componentsInChildren2)
			{
				Object.DestroyImmediate((Object)(object)((Component)item2).gameObject);
			}
			Object.DestroyImmediate((Object)(object)component);
			Player_Health val2 = ((Il2CppObjectBase)rigManager.health).TryCast<Player_Health>();
			if ((Object)(object)val2 != (Object)null)
			{
				val2.reloadLevelOnDeath = false;
				((Health)val2).healthMode = (HealthMode)0;
				GameObject val3 = Object.Instantiate<GameObject>(val2.Vignetter);
				((Renderer)val3.GetComponent<SkinnedMeshRenderer>()).enabled = false;
				((Object)val3).name = "Vignetter";
				val3.SetActive(false);
				val2.Vignetter = val3;
			}
			rigManager.physicsRig.headSfx.mouthSrc.spatialBlend = 1f;
			((Component)rigManager.physicsRig).GetComponentInChildren<PullCordDevice>(true)._bodyLogEnabled = true;
			rigManager.health._testVisualDamage = true;
			val.quickmenuEnabled = false;
			val._timeInput = false;
			rigManager.remapHeptaRig.doubleJump = false;
			Transform headset = val.headset;
			Object.DestroyImmediate((Object)(object)((Component)headset).GetComponent<AudioListener>());
			Object.DestroyImmediate((Object)(object)((Component)headset).GetComponent<CameraSettings>());
			Object.DestroyImmediate((Object)(object)((Component)headset).GetComponent<StreamingController>());
			Object.DestroyImmediate((Object)(object)((Component)headset).GetComponent<VolumetricRendering>());
			Object.DestroyImmediate((Object)(object)((Component)headset).GetComponent<UniversalAdditionalCameraData>());
			Object.DestroyImmediate((Object)(object)((Component)headset).GetComponent<Camera>());
			val.cameras = new Il2CppReferenceArray<Camera>(0L);
			val.onLastCameraUpdate = null;
			((Component)headset).tag = "Untagged";
			Object.DestroyImmediate((Object)(object)((Component)rigManager).GetComponentInChildren<PlayerAvatarArt>(true));
			((Component)((Component)rigManager).GetComponentInChildren<InventoryAmmoReceiver>()).GetComponent<Collider>().enabled = false;
			PhysHand component2 = ((Component)rigManager.physicsRig.leftHand).GetComponent<PhysHand>();
			PhysHand component3 = ((Component)rigManager.physicsRig.rightHand).GetComponent<PhysHand>();
			((Collider)component2.inventoryPlug).enabled = false;
			((Component)component2.inventoryPlug).gameObject.SetActive(false);
			((Collider)component3.inventoryPlug).enabled = false;
			((Component)component3.inventoryPlug).gameObject.SetActive(false);
			Object.DestroyImmediate((Object)(object)((Component)rigManager.ControllerRig.leftController).GetComponent<UIControllerInput>());
			Object.DestroyImmediate((Object)(object)((Component)rigManager.ControllerRig.rightController).GetComponent<UIControllerInput>());
			Internal_ClearHaptor(((Component)rigManager.ControllerRig.leftController).GetComponent<Haptor>());
			Internal_ClearHaptor(((Component)rigManager.ControllerRig.rightController).GetComponent<Haptor>());
			PersistentAssetCreator.SetupImpactProperties(rigManager);
			DelayUtilities.InvokeDelayed(delegate
			{
				Internal_SpatializeWind(((Component)rigManager).GetComponentInChildren<WindBuffetSFX>());
			}, 5);
		}

		private static void Internal_ClearHaptor(Haptor haptor)
		{
			haptor.hapticsAllowed = false;
			haptor.low_thr_freq = 0f;
			haptor.hap_duration = 0f;
			haptor.hap_frequency = 0f;
			haptor.hap_amplitude = 0f;
			haptor.hap_calc_t = 0f;
			haptor.hap_click_down_t = 0f;
			haptor.hap_click_down_frequency = 0f;
			haptor.hap_click_down_amplitude = 0f;
			haptor.hap_click_up_t = 0f;
			haptor.hap_click_up_frequency = 0f;
			haptor.hap_click_up_amplitude = 0f;
			haptor.hap_tap_duration = 0f;
			haptor.hap_tap_frequency = 0f;
			haptor.hap_tap_amplitude = 0f;
			haptor.hap_knock_duration = 0f;
			haptor.hap_knock_frequency = 0f;
			haptor.hap_knock_amplitude = 0f;
			haptor.hap_hit_mod = 0f;
			haptor.hap_hit_frequency = 0f;
			haptor.sin_gateCount = 0;
			haptor.hap_softSin_length = 0f;
			haptor.hap_softSin_freq = 0f;
			haptor.hap_max_softSin_amp = 0f;
			haptor.hap_min_softSin_amp = 0f;
			haptor.hap_hardSin_length = 0f;
			haptor.hap_hardSin_freq = 0f;
			haptor.hap_max_hardSin_amp = 0f;
			haptor.hap_min_hardSin_amp = 0f;
			((Behaviour)haptor).enabled = false;
		}

		private static void Internal_SpatializeWind(WindBuffetSFX sfx)
		{
			if (!((Object)(object)sfx == (Object)null) && Object.op_Implicit((Object)(object)sfx._buffetSrc))
			{
				sfx._buffetSrc.spatialBlend = 1f;
			}
		}
	}
	public static class RigAbstractor
	{
		public const int TransformSyncCount = 3;

		public static Transform GetSmoothTurnTransform(this RigManager manager)
		{
			return ((Component)((Il2CppObjectBase)manager.ControllerRig).TryCast<OpenControllerRig>().vrRoot).transform;
		}

		public static void FillTransformArray(ref Transform[] array, RigManager manager)
		{
			array = (Transform[])(object)new Transform[3];
			OpenControllerRig val = ((Il2CppObjectBase)manager.ControllerRig).TryCast<OpenControllerRig>();
			array[0] = val.headset;
			array[1] = ((Component)((ControllerRig)val).leftController).transform;
			array[2] = ((Component)((ControllerRig)val).rightController).transform;
		}
	}
}
namespace LabFusion.Preferences
{
	public static class CommonPreferences
	{
		public static readonly bool ShowMatureMods;

		public static bool NameTags
		{
			get
			{
				if (LobbyInfoManager.LobbyInfo.NameTags)
				{
					return ClientSettings.NameTags.Value;
				}
				return false;
			}
		}

		public static bool Mortality => LobbyInfoManager.LobbyInfo.Mortality;

		public static bool Knockout => LobbyInfoManager.LobbyInfo.Knockout;

		public static TimeScaleMode SlowMoMode => LobbyInfoManager.LobbyInfo.SlowMoMode;
	}
	public enum PrefUpdateMode
	{
		IGNORE,
		SERVER_UPDATE,
		CLIENT_UPDATE
	}
	public class FusionPref<T>
	{
		private readonly MelonPreferences_Category _category;

		private readonly MelonPreferences_Entry<T> _entry;

		private readonly PrefUpdateMode _mode;

		public Action<T> OnValueChanged { get; set; }

		public T Value
		{
			get
			{
				return _entry.Value;
			}
			set
			{
				_entry.Value = value;
				OnValueChanged?.Invoke(value);
				_category.SaveToFile(false);
				PushUpdate();
			}
		}

		public FusionPref(MelonPreferences_Category category, string name, T defaultValue, PrefUpdateMode mode = PrefUpdateMode.IGNORE)
		{
			_category = category;
			_entry = category.CreateEntry<T>(name, defaultValue, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			_mode = mode;
			FusionPreferences.OnPrefsLoaded += OnPrefsLoaded;
		}

		public void OnPrefsLoaded()
		{
			OnValueChanged?.Invoke(Value);
			PushUpdate();
		}

		private void PushUpdate()
		{
			switch (_mode)
			{
			case PrefUpdateMode.SERVER_UPDATE:
				SavedServerSettings.PushSettingsUpdate();
				break;
			case PrefUpdateMode.CLIENT_UPDATE:
				FusionPreferences.SendClientSettings();
				break;
			case PrefUpdateMode.IGNORE:
				break;
			}
		}
	}
	public static class FusionPreferences
	{
		public static MelonPreferences_Category prefCategory;

		public static event Action OnPrefsLoaded;

		internal static void SendClientSettings()
		{
			if (NetworkInfo.HasServer)
			{
				MessageRelay.RelayNative(new PlayerSettingsData
				{
					Settings = SerializedPlayerSettings.Create()
				}, NativeMessageTag.PlayerSettings, CommonMessageRoutes.ReliableToOtherClients);
			}
		}

		internal static void OnInitializePreferences()
		{
			prefCategory = MelonPreferences.CreateCategory("BONELAB Fusion");
			SavedServerSettings.OnInitialize(prefCategory);
			ClientSettings.OnInitialize(prefCategory);
			prefCategory.SaveToFile(false);
		}

		internal static void OnPreferencesLoaded()
		{
			FusionPreferences.OnPrefsLoaded?.Invoke();
		}
	}
}
namespace LabFusion.Preferences.Server
{
	public static class SavedServerSettings
	{
		public static FusionPref<bool> NameTags { get; private set; }

		public static FusionPref<bool> VoiceChat { get; private set; }

		public static FusionPref<bool> PlayerConstraining { get; private set; }

		public static FusionPref<ServerPrivacy> Privacy { get; private set; }

		public static FusionPref<TimeScaleMode> SlowMoMode { get; private set; }

		public static FusionPref<int> MaxPlayers { get; private set; }

		public static FusionPref<string> ServerName { get; private set; }

		public static FusionPref<string> ServerDescription { get; private set; }

		public static FusionPref<bool> Mortality { get; private set; }

		public static FusionPref<bool> FriendlyFire { get; private set; }

		public static FusionPref<bool> Knockout { get; private set; }

		public static FusionPref<int> KnockoutLength { get; private set; }

		public static FusionPref<float> MaxAvatarHeight { get; private set; }

		public static FusionPref<PermissionLevel> DevTools { get; private set; }

		public static FusionPref<PermissionLevel> Constrainer { get; private set; }

		public static FusionPref<PermissionLevel> CustomAvatars { get; private set; }

		public static FusionPref<PermissionLevel> Kicking { get; private set; }

		public static FusionPref<PermissionLevel> Banning { get; private set; }

		public static FusionPref<PermissionLevel> Teleportation { get; private set; }

		public static event Action OnSavedServerSettingsChanged;

		public static void OnInitialize(MelonPreferences_Category category)
		{
			PrefUpdateMode mode = PrefUpdateMode.SERVER_UPDATE;
			NameTags = new FusionPref<bool>(category, "Server Nametags Enabled", defaultValue: true, mode);
			VoiceChat = new FusionPref<bool>(category, "Server Voicechat Enabled", defaultValue: true, mode);
			PlayerConstraining = new FusionPref<bool>(category, "Server Player Constraints Enabled", defaultValue: false, mode);
			Privacy = new FusionPref<ServerPrivacy>(category, "Server Privacy", ServerPrivacy.PUBLIC, mode);
			SlowMoMode = new FusionPref<TimeScaleMode>(category, "Time Scale Mode", TimeScaleMode.LOW_GRAVITY, mode);
			MaxPlayers = new FusionPref<int>(category, "Max Players", 10, mode);
			ServerName = new FusionPref<string>(category, "Server Name", string.Empty, mode);
			ServerDescription = new FusionPref<string>(category, "Server Description", string.Empty, mode);
			Mortality = new FusionPref<bool>(category, "Server Mortality", defaultValue: true, mode);
			FriendlyFire = new FusionPref<bool>(category, "Friendly Fire", defaultValue: true, mode);
			Knockout = new FusionPref<bool>(category, "Knockout", defaultValue: false, mode);
			KnockoutLength = new FusionPref<int>(category, "Knockout Length", 10, mode);
			MaxAvatarHeight = new FusionPref<float>(category, "Max Avatar Height", 20f, mode);
			DevTools = new FusionPref<PermissionLevel>(category, "Dev Tools Allowed", PermissionLevel.DEFAULT, mode);
			Constrainer = new FusionPref<PermissionLevel>(category, "Constrainer Allowed", PermissionLevel.DEFAULT, mode);
			CustomAvatars = new FusionPref<PermissionLevel>(category, "Custom Avatars Allowed", PermissionLevel.DEFAULT, mode);
			Kicking = new FusionPref<PermissionLevel>(category, "Kicking Allowed", PermissionLevel.OPERATOR, mode);
			Banning = new FusionPref<PermissionLevel>(category, "Banning Allowed", PermissionLevel.OPERATOR, mode);
			Teleportation = new FusionPref<PermissionLevel>(category, "Teleportation", PermissionLevel.OPERATOR, mode);
		}

		public static void PushSettingsUpdate()
		{
			SavedServerSettings.OnSavedServerSettingsChanged.InvokeSafe("executing saved server settings changed hook");
		}
	}
}
namespace LabFusion.Preferences.Client
{
	public static class ClientSettings
	{
		public static FusionPref<string> NetworkLayerTitle { get; internal set; }

		public static FusionPref<int> ProxyPort { get; internal set; }

		public static FusionPref<float> MenuSize { get; internal set; }

		public static FusionPref<bool> NameTags { get; internal set; }

		public static Color NameTagColor => Color.HSVToRGB(NameTagHue.Value, NameTagSaturation.Value, NameTagValue.Value);

		public static FusionPref<float> NameTagHue { get; internal set; }

		public static FusionPref<float> NameTagSaturation { get; internal set; }

		public static FusionPref<float> NameTagValue { get; internal set; }

		public static FusionPref<string> Nickname { get; internal set; }

		public static FusionPref<NicknameVisibility> NicknameVisibility { get; internal set; }

		public static FusionPref<string> Description { get; internal set; }

		public static VoiceChatSettings VoiceChat { get; private set; }

		public static DownloadingSettings Downloading { get; private set; }

		public static SafetySettings Safety { get; private set; }

		public static void OnInitialize(MelonPreferences_Category category)
		{
			NetworkLayerTitle = new FusionPref<string>(category, "Network Layer Title", NetworkLayerDeterminer.GetDefaultLayer().Title);
			ProxyPort = new FusionPref<int>(category, "Proxy Port", 28340);
			MenuSize = new FusionPref<float>(category, "Menu Size", 1f);
			NameTags = new FusionPref<bool>(category, "Client Nametags Enabled", defaultValue: true, PrefUpdateMode.SERVER_UPDATE);
			NameTagHue = new FusionPref<float>(category, "NameTag Hue", 0f, PrefUpdateMode.CLIENT_UPDATE);
			NameTagSaturation = new FusionPref<float>(category, "NameTag Saturation", 0f, PrefUpdateMode.CLIENT_UPDATE);
			NameTagValue = new FusionPref<float>(category, "NameTag Value", 1f, PrefUpdateMode.CLIENT_UPDATE);
			Nickname = new FusionPref<string>(category, "Nickname", string.Empty);
			NicknameVisibility = new FusionPref<NicknameVisibility>(category, "Nickname Visibility", LabFusion.Senders.NicknameVisibility.SHOW_WITH_PREFIX, PrefUpdateMode.SERVER_UPDATE);
			LocalPlayer.Metadata.Nickname.SetValue(Nickname.Value);
			FusionPref<string> nickname = Nickname;
			nickname.OnValueChanged = (Action<string>)Delegate.Combine(nickname.OnValueChanged, (Action<string>)delegate(string v)
			{
				LocalPlayer.Metadata.Nickname.SetValue(v);
			});
			Description = new FusionPref<string>(category, "Description", string.Empty);
			LocalPlayer.Metadata.Description.SetValue(Description.Value);
			FusionPref<string> description = Description;
			description.OnValueChanged = (Action<string>)Delegate.Combine(description.OnValueChanged, (Action<string>)delegate(string v)
			{
				LocalPlayer.Metadata.Description.SetValue(v);
			});
			VoiceChat = new VoiceChatSettings();
			VoiceChat.CreatePrefs(category);
			Downloading = new DownloadingSettings();
			Downloading.CreatePrefs(category);
			Safety = new SafetySettings();
			Safety.CreatePrefs(category);
		}
	}
	public class DownloadingSettings
	{
		public const int DefaultMaxFileSize = 2000;

		public const int DefaultMaxLevelSize = 4000;

		public FusionPref<bool> DownloadSpawnables { get; private set; }

		public FusionPref<bool> DownloadAvatars { get; private set; }

		public FusionPref<bool> DownloadLevels { get; private set; }

		public FusionPref<bool> KeepDownloadedMods { get; private set; }

		public FusionPref<bool> NotifyDownloads { get; private set; }

		public FusionPref<int> MaxFileSize { get; private set; }

		public FusionPref<int> MaxLevelSize { get; private set; }

		public void CreatePrefs(MelonPreferences_Category category)
		{
			DownloadSpawnables = new FusionPref<bool>(category, "Download Spawnables", defaultValue: true);
			DownloadAvatars = new FusionPref<bool>(category, "Download Avatars", defaultValue: true);
			DownloadLevels = new FusionPref<bool>(category, "Download Levels", defaultValue: true);
			KeepDownloadedMods = new FusionPref<bool>(category, "Keep Downloaded Mods", defaultValue: false);
			NotifyDownloads = new FusionPref<bool>(category, "Notify Downloads", defaultValue: true);
			MaxFileSize = new FusionPref<int>(category, "Max File Size", 2000);
			MaxLevelSize = new FusionPref<int>(category, "Max Level Size", 4000);
		}
	}
	public class SafetySettings
	{
		public FusionPref<bool> FilterProfanity { get; private set; }

		public void CreatePrefs(MelonPreferences_Category category)
		{
			FilterProfanity = new FusionPref<bool>(category, "Filter Profanity", defaultValue: true);
		}
	}
	public class VoiceChatSettings
	{
		public FusionPref<bool> Muted { get; private set; }

		public FusionPref<bool> MutedIndicator { get; private set; }

		public FusionPref<bool> Deafened { get; private set; }

		public FusionPref<float> GlobalVolume { get; private set; }

		public FusionPref<string> InputDevice { get; private set; }

		public void CreatePrefs(MelonPreferences_Category category)
		{
			Muted = new FusionPref<bool>(category, "Muted", defaultValue: false);
			MutedIndicator = new FusionPref<bool>(category, "Muted Indicator", defaultValue: true);
			Deafened = new FusionPref<bool>(category, "Deafened", defaultValue: false);
			GlobalVolume = new FusionPref<float>(category, "GlobalMicVolume", 1f);
			InputDevice = new FusionPref<string>(category, "Input Device", string.Empty);
		}
	}
}
namespace LabFusion.Player
{
	public delegate void PlayerAvatarDelegate(Avatar avatar, string barcode);
	public static class LocalAvatar
	{
		private static float? _heightOverride = null;

		private static string? _avatarOverride = null;

		private static string? _storedAvatar = null;

		private static bool _overridingHeight = false;

		public static float? HeightOverride
		{
			get
			{
				return _heightOverride;
			}
			set
			{
				_heightOverride = value;
				RefreshAvatar();
			}
		}

		public static string? AvatarOverride
		{
			get
			{
				return _avatarOverride;
			}
			set
			{
				bool num = value != null;
				bool flag = _avatarOverride != null;
				if (num && !flag)
				{
					_storedAvatar = AvatarBarcode;
				}
				_avatarOverride = value;
				if (!num && flag && !string.IsNullOrWhiteSpace(_storedAvatar))
				{
					SwapAvatarCrate(_storedAvatar);
					_storedAvatar = null;
				}
				else
				{
					RefreshAvatar();
				}
			}
		}

		public static string? AvatarBarcode { get; private set; } = null;


		public static float AvatarHeight { get; private set; } = 1.76f;


		public static float AvatarMass { get; private set; } = 84f;


		public static event PlayerAvatarDelegate? OnAvatarChanged;

		internal static void OnInitializeMelon()
		{
			OnAvatarChanged += OnCheckAvatar;
		}

		internal static void InvokeAvatarChanged(Avatar avatar, string barcode)
		{
			AvatarBarcode = barcode;
			AvatarHeight = avatar.height;
			AvatarMass = avatar.massTotal;
			LocalAvatar.OnAvatarChanged?.InvokeSafe<PlayerAvatarDelegate, Avatar, string>(avatar, barcode, "executing LocalPlayer.OnAvatarChanged");
		}

		private static void OnCheckAvatar(Avatar avatar, string barcode)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			RigData.RigAvatarStats = new SerializedAvatarStats(avatar);
			RigData.RigAvatarId = barcode;
			PlayerSender.SendPlayerAvatar(RigData.RigAvatarStats, barcode);
			AvatarCrate crate = ((CrateReferenceT<AvatarCrate>)new AvatarCrateReference(barcode)).Crate;
			if ((Object)(object)crate != (Object)null)
			{
				LocalPlayer.Metadata.AvatarTitle.SetValue(((Scannable)crate).Title);
				LocalPlayer.Metadata.AvatarModID.SetValue(CrateFilterer.GetModID(((Crate)crate).Pallet));
			}
			OnOverrideAvatar(avatar, barcode, crate);
		}

		private static bool CheckAvatarPrivileges(AvatarCrate? crate)
		{
			if ((Object)(object)crate == (Object)null || ((Crate)crate).Pallet.IsInMarrowGame())
			{
				return true;
			}
			if (PlayerIDManager.LocalID == null || !PlayerIDManager.LocalID.TryGetPermissionLevel(out var level))
			{
				return true;
			}
			PermissionLevel customAvatars = LobbyInfoManager.LobbyInfo.CustomAvatars;
			if (!FusionPermissions.HasSufficientPermissions(level, customAvatars))
			{
				return false;
			}
			return true;
		}

		private static void OnOverrideAvatar(Avatar avatar, string barcode, AvatarCrate? crate)
		{
			if (!string.IsNullOrWhiteSpace(AvatarOverride) && !IsMatchingAvatar(barcode, AvatarOverride))
			{
				SwapAvatarCrate(AvatarOverride);
			}
			else if (!CheckAvatarPrivileges(crate))
			{
				SwapAvatarCrate(((ScannableReference)MarrowGameReferences.CalibrationAvatarReference).Barcode.ID);
			}
			else
			{
				OnOverrideHeight(avatar, barcode);
			}
		}

		private static float? ProcessHeightOverride(float avatarHeight)
		{
			float? heightOverride = HeightOverride;
			if (heightOverride.HasValue)
			{
				return heightOverride;
			}
			float num = ManagedMathf.Clamp(LobbyInfoManager.LobbyInfo.MaxAvatarHeight, 2f, 30f);
			if (NetworkInfo.HasServer && avatarHeight > num)
			{
				return num;
			}
			return null;
		}

		private static void OnOverrideHeight(Avatar avatar, string barcode)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (_overridingHeight)
			{
				_overridingHeight = false;
				return;
			}
			float? num = ProcessHeightOverride(avatar.height);
			if (num.HasValue)
			{
				float height = avatar.height;
				float value = num.Value;
				Vector3 newScale = value / height * ((Component)avatar).transform.localScale;
				_overridingHeight = true;
				RigData.Refs.SwapAvatarCrate(barcode, null, delegate(string _, GameObject newAvatar)
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					newAvatar.transform.localScale = newScale;
				});
			}
		}

		public static void RefreshAvatar()
		{
			if (RigData.HasPlayer)
			{
				RigManager rigManager = RigData.Refs.RigManager;
				rigManager.SwapAvatarCrate(((ScannableReference)rigManager.AvatarCrate).Barcode, true, (Action<bool>)null);
			}
		}

		public static void SwapAvatarCrate(string barcode)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			if (!RigData.HasPlayer)
			{
				return;
			}
			RigManager rigManager = RigData.Refs.RigManager;
			rigManager.SwapAvatarCrate(new Barcode(barcode), true, Action<bool>.op_Implicit((Action<bool>)delegate(bool success)
			{
				if (!success)
				{
					rigManager.SwapAvatarCrate(((ScannableReference)MarrowGameReferences.CalibrationAvatarReference).Barcode, true, (Action<bool>)null);
				}
			}));
		}

		public static bool IsMatchingAvatar(string barcode, string target)
		{
			if (!(barcode == target))
			{
				return barcode == ((ScannableReference)MarrowGameReferences.CalibrationAvatarReference).Barcode.ID;
			}
			return true;
		}
	}
	public static class LocalControls
	{
		private static bool _disableInteraction;

		private static bool _disableSlowMo;

		public static bool LockedMovement { get; set; }

		public static bool DisableInteraction
		{
			get
			{
				return _disableInteraction;
			}
			set
			{
				_disableInteraction = value;
				if (value)
				{
					LocalPlayer.ReleaseGrips();
				}
			}
		}

		public static bool DisableSlowMo
		{
			get
			{
				return _disableSlowMo;
			}
			set
			{
				_disableSlowMo = value;
				OnOverrideSlowMo();
			}
		}

		public static bool SlowMoEnabled
		{
			get
			{
				if (!NetworkInfo.HasServer)
				{
					return true;
				}
				if (DisableSlowMo)
				{
					return false;
				}
				if (CommonPreferences.SlowMoMode == TimeScaleMode.DISABLED)
				{
					return false;
				}
				return true;
			}
		}

		public static bool DisableAmmoPouch { get; set; }

		public static bool DisableInventory { get; set; }

		internal static void OnInitializeMelon()
		{
			MultiplayerHooking.OnMainSceneInitialized += OnMainSceneInitialized;
			LobbyInfoManager.OnLobbyInfoChanged += OnLobbyInfoChanged;
		}

		private static void OnMainSceneInitialized()
		{
			OnOverrideSlowMo();
		}

		private static void OnLobbyInfoChanged()
		{
			OnOverrideSlowMo();
		}

		internal static void OnFixedUpdate()
		{
			UpdateSlowMo();
		}

		private static void OnOverrideSlowMo()
		{
			TimeManager.slowMoEnabled = SlowMoEnabled;
		}

		private static void UpdateSlowMo()
		{
			if (NetworkInfo.HasServer && RigData.HasPlayer && CommonPreferences.SlowMoMode == TimeScaleMode.LOW_GRAVITY)
			{
				ApplyLowGravity();
			}
		}

		private static void ApplyLowGravity()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (!TimeManager.slowMoEnabled)
			{
				return;
			}
			RigManager rigManager = RigData.Refs.RigManager;
			if (TimeManager.cur_intensity <= 0f)
			{
				return;
			}
			float num = 1f - 1f / TimeManager.cur_intensity;
			Vector3 val = -Physics.gravity * num;
			Enumerator<Rigidbody> enumerator = rigManager.physicsRig.selfRbs.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Rigidbody current = enumerator.Current;
				if (current.useGravity)
				{
					current.AddForce(val, (ForceMode)5);
				}
			}
		}
	}
	public static class LocalHealth
	{
		private static float? _vitalityOverride;

		private static bool _wasOverridingVitality;

		private static bool? _regenerationOverride;

		private static bool? _mortalityOverride;

		public static float? VitalityOverride
		{
			get
			{
				return _vitalityOverride;
			}
			set
			{
				_vitalityOverride = value;
				OnOverrideHealth();
			}
		}

		public static bool? RegenerationOverride
		{
			get
			{
				return _regenerationOverride;
			}
			set
			{
				_regenerationOverride = value;
				OnOverrideHealth();
			}
		}

		public static bool? MortalityOverride
		{
			get
			{
				return _mortalityOverride;
			}
			set
			{
				_mortalityOverride = value;
				OnOverrideHealth();
			}
		}

		public static event Action OnRespawn;

		public static event Action<Attack, BodyPart, PlayerID> OnAttackedByPlayer;

		public static void SetFullHealth()
		{
			if (RigData.HasPlayer)
			{
				Player_Health health = RigData.Refs.Health;
				((Health)health).SetFullHealth();
				health.isInstaDying = false;
			}
		}

		internal static void OnInitializeMelon()
		{
			LocalAvatar.OnAvatarChanged += OnAvatarChanged;
			LobbyInfoManager.OnLobbyInfoChanged += OnLobbyInfoChanged;
			OnRespawn += OnRespawned;
		}

		private static void OnRespawned()
		{
			if (NetworkInfo.HasServer && RigData.HasPlayer)
			{
				RigData.Refs.Health.isInstaDying = false;
			}
		}

		internal static void InvokeRespawn()
		{
			LocalHealth.OnRespawn?.InvokeSafe("executing LocalHealth.OnRespawn");
		}

		internal static void InvokeAttackedByPlayer(Attack attack, BodyPart bodyPart, PlayerID playerId)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			LocalHealth.OnAttackedByPlayer?.InvokeSafe<Action<Attack, BodyPart, PlayerID>, Attack, BodyPart, PlayerID>(attack, bodyPart, playerId, "executing LocalHealth.OnAttackedByPlayer");
		}

		private static void OnLobbyInfoChanged()
		{
			OnOverrideHealth();
		}

		private static void OnAvatarChanged(Avatar avatar, string barcode)
		{
			OnOverrideHealth();
		}

		private static void OnOverrideHealth()
		{
			if (NetworkInfo.HasServer && RigData.HasPlayer)
			{
				Avatar avatar = RigData.Refs.RigManager.avatar;
				Player_Health health = RigData.Refs.Health;
				if (VitalityOverride.HasValue)
				{
					avatar._vitality = VitalityOverride.Value;
					((Health)health).SetAvatar(avatar);
					_wasOverridingVitality = true;
				}
				else if (_wasOverridingVitality)
				{
					avatar.RefreshBodyMeasurements();
					((Health)health).SetAvatar(avatar);
					_wasOverridingVitality = false;
				}
				bool flag = CommonPreferences.Mortality && !CommonPreferences.Knockout;
				if (MortalityOverride.HasValue)
				{
					flag = MortalityOverride.Value;
				}
				bool valueOrDefault = RegenerationOverride.GetValueOrDefault(true);
				if (flag && valueOrDefault)
				{
					((Health)health).healthMode = (HealthMode)1;
				}
				else if (flag && !valueOrDefault)
				{
					((Health)health).healthMode = (HealthMode)2;
				}
				else
				{
					((Health)health).healthMode = (HealthMode)0;
				}
			}
		}
	}
	public static class LocalInventory
	{
		public static void SetAmmo(int count)
		{
			AmmoInventory instance = AmmoInventory.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.ClearAmmo();
				instance.AddCartridge(instance.lightAmmoGroup, count);
				instance.AddCartridge(instance.heavyAmmoGroup, count);
				instance.AddCartridge(instance.mediumAmmoGroup, count);
			}
		}

		public static void AddAmmo(int count)
		{
			AmmoInventory instance = AmmoInventory.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.AddCartridge(instance.lightAmmoGroup, count);
				instance.AddCartridge(instance.heavyAmmoGroup, count);
				instance.AddCartridge(instance.mediumAmmoGroup, count);
			}
		}

		public static void ClearAmmo()
		{
			AmmoInventory instance = AmmoInventory.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.ClearAmmo();
			}
		}
	}
	public delegate void PlayerGrabDelegate(Hand hand, Grip grip);
	public static class LocalPlayer
	{
		private static string _username = "Player";

		public static PlayerGrabDelegate? OnGrab { get; set; }

		public static PlayerGrabDelegate? OnRelease { get; set; }

		public static Action<RigManager>? OnLocalRigCreated { get; set; }

		public static bool RagdollOnDeath => NetworkInfo.HasServer;

		public static string Username
		{
			get
			{
				return _username;
			}
			set
			{
				_username = value;
				Metadata.Username.SetValue(value);
				LocalPlayer.OnUsernameChanged?.InvokeSafe(value, "executing OnUsernameChanged");
			}
		}

		public static PlayerMetadata Metadata { get; } = new PlayerMetadata();


		public static event Action<string>? OnUsernameChanged;

		public static event Action? OnApplyInitialMetadata;

		internal static void OnInitializeMelon()
		{
			Metadata.CreateMetadata();
			NetworkMetadata metadata = Metadata.Metadata;
			metadata.OnTrySetMetadata = (MetadataSetDelegate)Delegate.Combine(metadata.OnTrySetMetadata, new MetadataSetDelegate(OnTrySetMetadata));
			NetworkMetadata metadata2 = Metadata.Metadata;
			metadata2.OnTryRemoveMetadata = (MetadataRemoveDelegate)Delegate.Combine(metadata2.OnTryRemoveMetadata, new MetadataRemoveDelegate(OnTryRemoveMetadata));
			LocalAvatar.OnInitializeMelon();
			LocalHealth.OnInitializeMelon();
			LocalVision.OnInitializeMelon();
			LocalControls.OnInitializeMelon();
		}

		internal static void OnFixedUpdate()
		{
			LocalControls.OnFixedUpdate();
		}

		private static bool OnTrySetMetadata(string key, string value)
		{
			Metadata.Metadata.ForceSetLocalMetadata(key, value);
			PlayerIDManager.LocalID?.Metadata.Metadata.TrySetMetadata(key, value);
			return true;
		}

		private static bool OnTryRemoveMetadata(string key)
		{
			Metadata.Metadata.ForceRemoveLocalMetadata(key);
			PlayerIDManager.LocalID?.Metadata.Metadata.TryRemoveMetadata(key);
			return true;
		}

		internal static void InvokeApplyInitialMetadata()
		{
			LocalPlayer.OnApplyInitialMetadata?.InvokeSafe("executing LocalPlayer.OnApplyInitialMetadata");
		}

		public static NetworkPlayer? GetNetworkPlayer()
		{
			if (!NetworkInfo.HasServer)
			{
				return null;
			}
			if (NetworkPlayerManager.TryGetPlayer((byte)PlayerIDManager.LocalID, out NetworkPlayer player))
			{
				return player;
			}
			return null;
		}

		public static void ClearConstraints()
		{
			if (!RigData.HasPlayer)
			{
				return;
			}
			try
			{
				foreach (ConstraintTracker componentsInChild in ((Component)RigData.Refs.RigManager.physicsRig).GetComponentsInChildren<ConstraintTracker>())
				{
					componentsInChild.DeleteConstraint();
				}
			}
			catch (Exception e)
			{
				FusionLogger.LogException("deleting constraints on local player", e);
			}
		}

		public static void ReleaseGrips()
		{
			if (RigData.HasPlayer)
			{
				PhysicsRig physicsRig = RigData.Refs.RigManager.physicsRig;
				physicsRig.leftHand.TryDetach();
				physicsRig.rightHand.TryDetach();
			}
		}

		public static void TeleportToCheckpoint()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (RigData.HasPlayer)
			{
				RigManager rigManager = RigData.Refs.RigManager;
				TeleportToPosition(rigManager.checkpointPosition, rigManager.checkpointFwd);
			}
		}

		public static void TeleportToPosition(Vector3 position)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (RigData.HasPlayer)
			{
				RigData.Refs.RigManager.TeleportToPosition(position);
			}
		}

		public static void TeleportToPosition(Vector3 position, Vector3 forward)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (RigData.HasPlayer)
			{
				RigData.Refs.RigManager.TeleportToPosition(position, forward);
			}
		}
	}
	public static class LocalRagdoll
	{
		[CompilerGenerated]
		private sealed class <KnockoutCoroutine>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public bool blind;

			public float length;

			public RigManager rigManager;

			private float <elapsed>5__2;

			private float <eyeLength>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <KnockoutCoroutine>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					LocalPlayer.ReleaseGrips();
					ToggleRagdoll(ragdolled: true);
					LocalVision.Blind = blind;
					LocalVision.BlindColor = Color.black;
					_knockedOut = true;
					<elapsed>5__2 = 0f;
					<eyeLength>5__3 = Mathf.Min(10f, length);
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__2 <= length)
				{
					<elapsed>5__2 += TimeReferences.DeltaTime;
					float num = Mathf.Max(length - <eyeLength>5__3, 0f);
					float num2 = Mathf.Max(<elapsed>5__2 - num, 0f) / <eyeLength>5__3;
					LocalVision.BlindColor = Color.Lerp(Color.black, Color.clear, Mathf.Pow(num2, 3f));
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				_knockedOut = false;
				LocalVision.Blind = false;
				LocalVision.BlindColor = Color.black;
				if ((Object)(object)rigManager == (Object)null)
				{
					return false;
				}
				rigManager.health.SetFullHealth();
				ToggleRagdoll(ragdolled: false);
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static bool _knockedOut;

		public static bool KnockedOut => _knockedOut;

		public static bool RagdollLocked
		{
			get
			{
				if (!RigData.HasPlayer)
				{
					return false;
				}
				if (RigData.Refs.RigManager.health.deathIsImminent && GamemodeManager.IsGamemodeStarted && GamemodeManager.ActiveGamemode.DisableManualUnragdoll)
				{
					return true;
				}
				return KnockedOut;
			}
		}

		public static void ToggleRagdoll(bool ragdolled)
		{
			if (RigData.HasPlayer)
			{
				PhysicsRigPatches.ForceAllowUnragdoll = true;
				PhysicsRig physicsRig = RigData.Refs.RigManager.physicsRig;
				if (ragdolled)
				{
					physicsRig.ShutdownRig();
					physicsRig.RagdollRig();
				}
				else
				{
					physicsRig.TurnOnRig();
					physicsRig.UnRagdollRig();
				}
				PhysicsRigPatches.ForceAllowUnragdoll = false;
			}
		}

		public static void Knockout(float length)
		{
			Knockout(length, blind: true);
		}

		public static void Knockout(float length, bool blind)
		{
			if (RigData.HasPlayer && !KnockedOut)
			{
				MelonCoroutines.Start(KnockoutCoroutine(RigData.Refs.RigManager, length, blind));
			}
		}

		[IteratorStateMachine(typeof(<KnockoutCoroutine>d__8))]
		private static IEnumerator KnockoutCoroutine(RigManager rigManager, float length, bool blind)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <KnockoutCoroutine>d__8(0)
			{
				rigManager = rigManager,
				length = length,
				blind = blind
			};
		}
	}
	public static class LocalVision
	{
		private static bool _blind = false;

		private static Color _blindColor = Color.black;

		private static GameObject _blindnessGameObject = null;

		private static RawImage _blindnessImage = null;

		public static bool Blind
		{
			get
			{
				return _blind;
			}
			set
			{
				_blind = value;
				ApplyVisionSettings();
			}
		}

		public static Color BlindColor
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return _blindColor;
			}
			set
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				_blindColor = value;
				ApplyVisionSettings();
			}
		}

		internal static void OnInitializeMelon()
		{
			MultiplayerHooking.OnMainSceneInitialized += OnMainSceneInitialized;
		}

		private static void OnMainSceneInitialized()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			_blindnessGameObject = new GameObject("Blindness");
			_blindnessGameObject.AddComponent<Canvas>().renderMode = (RenderMode)2;
			Transform transform = _blindnessGameObject.transform;
			transform.parent = RigData.Refs.Headset;
			transform.localPosition = Vector3Extensions.forward * 0.05f;
			transform.localRotation = Quaternion.Euler(0f, 180f, 0f);
			transform.localScale = Vector3Extensions.one * 10f;
			_blindnessImage = _blindnessGameObject.AddComponent<RawImage>();
			ApplyVisionSettings();
		}

		private static void ApplyVisionSettings()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_blindnessImage == (Object)null))
			{
				_blindnessGameObject.SetActive(Blind);
				((Graphic)_blindnessImage).color = BlindColor;
			}
		}
	}
	public static class NetworkCombatManager
	{
		public static bool CanAttack(NetworkPlayer player)
		{
			if (GamemodeManager.IsGamemodeStarted)
			{
				return GamemodeManager.ActiveGamemode.CanAttack(player.PlayerID);
			}
			return LobbyInfoManager.LobbyInfo.FriendlyFire;
		}
	}
	public class PlayerID : LabFusion.Network.Serialization.INetSerializable, IEquatable<PlayerID>
	{
		private bool _isValid;

		private readonly PlayerMetadata _metadata = new PlayerMetadata();

		private Action _onDestroyedEvent;

		private List<string> _equippedItems = new List<string>();

		public bool IsMe => PlatformID == PlayerIDManager.LocalPlatformID;

		public bool IsValid => _isValid;

		public bool IsHost => SmallID == 0;

		public ulong PlatformID { get; private set; }

		public byte SmallID { get; private set; }

		public PlayerMetadata Metadata => _metadata;

		public List<string> EquippedItems => _equippedItems;

		public static event Action<PlayerID, string, string> OnMetadataChangedEvent;

		public static event Action<PlayerID, string, string> OnMetadataRemovedEvent;

		public event Action OnDestroyedEvent
		{
			add
			{
				if (!_isValid)
				{
					value();
				}
				else
				{
					_onDestroyedEvent = (Action)Delegate.Combine(_onDestroyedEvent, value);
				}
			}
			remove
			{
				_onDestroyedEvent = (Action)Delegate.Remove(_onDestroyedEvent, value);
			}
		}

		public PlayerID()
		{
			_isValid = false;
		}

		public PlayerID(ulong longId, byte smallId, Dictionary<string, string> metadata, List<string> equippedItems)
		{
			Metadata.CreateMetadata();
			PlatformID = longId;
			SmallID = smallId;
			_equippedItems = equippedItems;
			foreach (KeyValuePair<string, string> metadatum in metadata)
			{
				Metadata.Metadata.ForceSetLocalMetadata(metadatum.Key, metadatum.Value);
			}
			OnAfterCreateId();
		}

		private void OnAfterCreateId()
		{
			HookMetadata();
			_isValid = true;
		}

		private void HookMetadata()
		{
			NetworkMetadata metadata = Metadata.Metadata;
			metadata.OnTrySetMetadata = (MetadataSetDelegate)Delegate.Combine(metadata.OnTrySetMetadata, new MetadataSetDelegate(OnTrySetMetadata));
			NetworkMetadata metadata2 = Metadata.Metadata;
			metadata2.OnTryRemoveMetadata = (MetadataRemoveDelegate)Delegate.Combine(metadata2.OnTryRemoveMetadata, new MetadataRemoveDelegate(OnTryRemoveMetadata));
			Metadata.Metadata.OnMetadataChanged += OnMetadataChanged;
			Metadata.Metadata.OnMetadataRemoved += OnMetadataRemoved;
		}

		private void UnhookMetadata()
		{
			Metadata.DestroyMetadata();
		}

		private void OnMetadataChanged(string key, string value)
		{
			PlayerID.OnMetadataChangedEvent?.InvokeSafe(this, key, value, "executing OnMetadataChangedEvent");
		}

		private void OnMetadataRemoved(string key, string value)
		{
			PlayerID.OnMetadataRemovedEvent?.InvokeSafe(this, key, value, "executing OnMetadataRemovedEvent");
		}

		private bool OnTrySetMetadata(string key, string value)
		{
			if (!HasMetadataPermissions())
			{
				return false;
			}
			PlayerSender.SendPlayerMetadataRequest(SmallID, key, value);
			return true;
		}

		private bool OnTryRemoveMetadata(string key)
		{
			return false;
		}

		private bool HasMetadataPermissions()
		{
			if (!NetworkInfo.IsHost)
			{
				return IsMe;
			}
			return true;
		}

		public bool Equals(PlayerID other)
		{
			if (other == null)
			{
				return false;
			}
			return SmallID == other.SmallID;
		}

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

		public override int GetHashCode()
		{
			return SmallID.GetHashCode();
		}

		public static implicit operator byte(PlayerID id)
		{
			return id.SmallID;
		}

		public static implicit operator ulong(PlayerID id)
		{
			return id.PlatformID;
		}

		public static bool IsNullOrInvalid(PlayerID id)
		{
			if (id != null)
			{
				return !id.IsValid;
			}
			return true;
		}

		public bool HasEquipped(PointItem item)
		{
			if (IsMe)
			{
				return item.IsEquipped;
			}
			return EquippedItems.Contains(item.Barcode);
		}

		internal void ForceSetEquipped(string barcode, bool value)
		{
			if (value && !_equippedItems.Contains(barcode))
			{
				_equippedItems.Add(barcode);
			}
			else if (!value && _equippedItems.Contains(barcode))
			{
				_equippedItems.Remove(barcode);
			}
			PointItemManager.OnEquipChanged(this, barcode, value);
		}

		public void Insert()
		{
			if (PlayerIDManager.PlayerIDs.Any((PlayerID id) => id.SmallID == SmallID))
			{
				List<PlayerID> list = PlayerIDManager.PlayerIDs.Where((PlayerID id) => id.SmallID == SmallID).ToList();
				for (int i = 0; i < list.Count; i++)
				{
					list[i].Cleanup();
				}
			}
			PlayerIDManager.InsertPlayerID(this);
		}

		public void Cleanup()
		{
			if (!_isValid)
			{
				FusionLogger.Warn("Attempted to cleanup a PlayerId that was not valid!");
				return;
			}
			PlayerIDManager.RemovePlayerID(this);
			if (PlayerIDManager.LocalID == this)
			{
				PlayerIDManager.RemoveLocalID();
			}
			_isValid = false;
			_onDestroyedEvent?.Invoke();
			_onDestroyedEvent = null;
			UnhookMetadata();
		}

		public int? GetSize()
		{
			return 9 + Metadata.Metadata.LocalDictionary.GetSize() + EquippedItems.GetSize();
		}

		public void Serialize(INetSerializer serializer)
		{
			if (serializer.IsReader)
			{
				Metadata.CreateMetadata();
			}
			ulong value = PlatformID;
			byte value2 = SmallID;
			Dictionary<string, string> value3 = Metadata.Metadata.LocalDictionary;
			string[] value4 = _equippedItems.ToArray();
			serializer.SerializeValue(ref value);
			serializer.SerializeValue(ref value2);
			NetSerializerExtensions.SerializeValue(serializer, ref value3);
			serializer.SerializeValue(ref value4);
			if (!serializer.IsReader)
			{
				return;
			}
			PlatformID = value;
			SmallID = value2;
			foreach (KeyValuePair<string, string> item in value3)
			{
				Metadata.Metadata.ForceSetLocalMetadata(item.Key, item.Value);
			}
			string[] array = value4;
			foreach (string barcode in array)
			{
				ForceSetEquipped(barcode, value: true);
			}
			OnAfterCreateId();
		}
	}
	public static class PlayerIDManager
	{
		public const int MaxNameLength = 32;

		public const int MinPlayerID = 0;

		public const int MaxPlayerID = 255;

		public static readonly HashSet<PlayerID> PlayerIDs = new HashSet<PlayerID>();

		public static readonly Dictionary<byte, PlayerID> SmallIDLookup = new Dictionary<byte, PlayerID>();

		public static readonly Dictionary<ulong, PlayerID> PlatformIDLookup = new Dictionary<ulong, PlayerID>();

		public static readonly HashSet<byte> ReservedSmallIDs = new HashSet<byte>();

		public const byte HostSmallID = 0;

		public static int PlayerCount => PlayerIDs.Count;

		public static bool HasOtherPlayers => PlayerCount > 1;

		public static ulong LocalPlatformID { get; private set; }

		public static byte LocalSmallID { get; private set; }

		public static PlayerID LocalID { get; private set; }

		public static void InsertPlayerID(PlayerID playerID)
		{
			if (SmallIDLookup.TryGetValue(playerID.SmallID, out var value))
			{
				value.Cleanup();
			}
			PlayerIDs.Add(playerID);
			SmallIDLookup[playerID.SmallID] = playerID;
			PlatformIDLookup[playerID.PlatformID] = playerID;
			ReserveSmallID(playerID.SmallID);
		}

		public static void RemovePlayerID(PlayerID playerID)
		{
			PlayerIDs.Remove(playerID);
			SmallIDLookup.Remove(playerID.SmallID);
			PlatformIDLookup.Remove(playerID.PlatformID);
			UnreserveSmallID(playerID.SmallID);
		}

		public static void ReserveSmallID(byte smallID)
		{
			ReservedSmallIDs.Add(smallID);
		}

		public static void UnreserveSmallID(byte smallID)
		{
			ReservedSmallIDs.Remove(smallID);
		}

		public static bool IsSmallIDReserved(byte smallID)
		{
			return ReservedSmallIDs.Contains(smallID);
		}

		public static byte? GetUniquePlayerID()
		{
			for (byte b = 0; b < byte.MaxValue; b++)
			{
				if (!IsSmallIDReserved(b))
				{
					return b;
				}
			}
			return null;
		}

		public static PlayerID GetHostID()
		{
			return GetPlayerID(0);
		}

		public static PlayerID GetPlayerID(byte smallID)
		{
			if (SmallIDLookup.TryGetValue(smallID, out var value))
			{
				return value;
			}
			return null;
		}

		public static PlayerID GetPlayerID(ulong platformID)
		{
			if (PlatformIDLookup.TryGetValue(platformID, out var value))
			{
				return value;
			}
			return null;
		}

		public static bool HasPlayerID(byte smallID)
		{
			return SmallIDLookup.ContainsKey(smallID);
		}

		public static bool HasPlayerID(ulong platformID)
		{
			return PlatformIDLookup.ContainsKey(platformID);
		}

		internal static void ApplyLocalID()
		{
			PlayerID playerID = GetPlayerID(LocalPlatformID);
			if (playerID != null)
			{
				LocalID = playerID;
				LocalSmallID = playerID.SmallID;
			}
			else
			{
				LocalID = null;
				LocalSmallID = 0;
			}
		}

		internal static void RemoveLocalID()
		{
			LocalID = null;
		}

		public static void SetLongID(ulong longID)
		{
			LocalPlatformID = longID;
		}
	}
	public class PlayerMetadata
	{
		public NetworkMetadata Metadata { get; private set; }

		public MetadataVariable Username { get; private set; }

		public MetadataVariable Nickname { get; private set; }

		public MetadataVariable Description { get; private set; }

		public MetadataBool Loading { get; private set; }

		public MetadataVariable LevelBarcode { get; private set; }

		public MetadataVariable AvatarTitle { get; private set; }

		public MetadataInt AvatarModID { get; private set; }

		public MetadataVariable PermissionLevel { get; private set; }

		public bool IsValid { get; private set; }

		public void CreateMetadata()
		{
			Metadata = new NetworkMetadata();
			Username = new MetadataVariable("Username", Metadata);
			Nickname = new MetadataVariable("Nickname", Metadata);
			Description = new MetadataVariable("Description", Metadata);
			Loading = new MetadataBool("Loading", Metadata);
			LevelBarcode = new MetadataVariable("LevelBarcode", Metadata);
			AvatarTitle = new MetadataVariable("AvatarTitle", Metadata);
			AvatarModID = new MetadataInt("AvatarModID", Metadata);
			PermissionLevel = new MetadataVariable("PermissionLevel", Metadata);
			IsValid = true;
		}

		public void DestroyMetadata()
		{
			IsValid = false;
			Username.Remove();
			Nickname.Remove();
			Description.Remove();
			Loading.Remove();
			LevelBarcode.Remove();
			AvatarTitle.Remove();
			AvatarModID.Remove();
			PermissionLevel.Remove();
			Metadata = null;
			Username = null;
			Nickname = null;
			Description = null;
			Loading = null;
			LevelBarcode = null;
			AvatarTitle = null;
			AvatarModID = null;
			PermissionLevel = null;
		}
	}
	public struct PlayerReference : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 1;

		public byte ID;

		public readonly int? GetSize()
		{
			return 1;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref ID);
		}

		public readonly bool TryGetPlayer(out PlayerID player)
		{
			player = GetPlayer();
			return player != null;
		}

		public readonly PlayerID GetPlayer()
		{
			return PlayerIDManager.GetPlayerID(ID);
		}

		public PlayerReference()
			: this(0)
		{
		}

		public PlayerReference(PlayerID player)
			: this(player.SmallID)
		{
		}

		public PlayerReference(byte id)
		{
			ID = id;
		}
	}
}
namespace LabFusion.Permissions
{
	public enum MasterStatus
	{
		None,
		Master
	}
	public static class MasterPermissionsManager
	{
		public static bool IsMaster(ulong platformID)
		{
			return TrustedListManager.VerifyPlayer(platformID, string.Empty) == TrustedStatus.Master;
		}

		public static MasterStatus GetMasterStatus(ulong platformID)
		{
			if (IsMaster(platformID))
			{
				return MasterStatus.Master;
			}
			return MasterStatus.None;
		}
	}
}
namespace LabFusion.Network
{
	public class ComponentIndexData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 4;

		public ushort EntityID;

		public ushort ComponentIndex;

		public int? GetSize()
		{
			return 4;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref EntityID);
			serializer.SerializeValue(ref ComponentIndex);
		}

		public static ComponentIndexData Create(ushort entityId, ushort componentIndex)
		{
			return new ComponentIndexData
			{
				EntityID = entityId,
				ComponentIndex = componentIndex
			};
		}
	}
	public class ComponentPathData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 14;

		public bool HasEntity;

		public ushort EntityID;

		public ushort ComponentIndex;

		public ComponentHashData HashData;

		public int? GetSize()
		{
			return 14;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref HasEntity);
			serializer.SerializeValue(ref EntityID);
			serializer.SerializeValue(ref ComponentIndex);
			bool value = HashData != null;
			serializer.SerializeValue(ref value);
			if (value)
			{
				NetSerializerExtensions.SerializeValue(serializer, ref HashData);
			}
		}

		public static ComponentPathData CreateFromComponent<TComponent, TExtender>(TComponent component, ComponentHashTable<TComponent> hashTable, FusionComponentCache<TComponent, NetworkEntity> cache) where TComponent : Component where TExtender : EntityComponentArrayExtender<TComponent>
		{
			ComponentHashData dataFromComponent = hashTable.GetDataFromComponent(component);
			bool hasEntity = false;
			ushort entityID = 0;
			ushort componentIndex = 0;
			if (cache.TryGet(component, out var value))
			{
				hasEntity = true;
				TExtender extender = value.GetExtender<TExtender>();
				entityID = value.ID;
				componentIndex = extender.GetIndex(component).Value;
			}
			return new ComponentPathData
			{
				HasEntity = hasEntity,
				EntityID = entityID,
				ComponentIndex = componentIndex,
				HashData = dataFromComponent
			};
		}

		public bool TryGetComponent<TComponent, TExtender>(ComponentHashTable<TComponent> hashTable, out TComponent component) where TComponent : Component where TExtender : EntityComponentArrayExtender<TComponent>
		{
			component = default(TComponent);
			if (HasEntity)
			{
				NetworkEntity entity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(EntityID);
				if (entity == null)
				{
					return false;
				}
				TExtender extender = entity.GetExtender<TExtender>();
				if (extender == null)
				{
					return false;
				}
				component = extender.GetComponent(ComponentIndex);
				return (Object)(object)component != (Object)null;
			}
			component = hashTable.GetComponentFromData(HashData);
			return (Object)(object)component != (Object)null;
		}
	}
	public class EmptyData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 0;

		public int? GetSize()
		{
			return 0;
		}

		public void Serialize(INetSerializer serializer)
		{
		}
	}
	public class EntityPlayerData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 3;

		public byte PlayerID;

		public NetworkEntityReference Entity;

		public int? GetSize()
		{
			return 3;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref PlayerID);
			NetSerializerExtensions.SerializeValue(serializer, ref Entity);
		}
	}
	public class PlayerMetadataData : LabFusion.Network.Serialization.INetSerializable
	{
		public PlayerReference Player;

		public string Key;

		public string Value;

		public int? GetSize()
		{
			return 1 + Key.GetSize() + Value.GetSize();
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref Player);
			serializer.SerializeValue(ref Key);
			serializer.SerializeValue(ref Value);
		}
	}
	public class EmptyNetworkLayer : NetworkLayer
	{
		public override string Title => "Empty";

		public override string Platform => "Empty";

		public override void Disconnect(string reason = "")
		{
		}

		public override void DisconnectUser(ulong platformID)
		{
		}

		public override void StartServer()
		{
		}

		public override bool CheckSupported()
		{
			return false;
		}

		public override bool CheckValidation()
		{
			return true;
		}

		public override void OnInitializeLayer()
		{
			FusionLogger.Log("Initialized mod with an empty networking layer!", ConsoleColor.Magenta);
			FusionLogger.Log("This usually means all other network layers failed to initialize, or you selected Empty in the settings.", ConsoleColor.Magenta);
		}

		public override void OnDeinitializeLayer()
		{
		}

		public override void LogIn()
		{
			throw new NotImplementedException();
		}

		public override void LogOut()
		{
			throw new NotImplementedException();
		}
	}
	public static class MessageRelay
	{
		public static void RelayNative<TData>(TData data, byte tag, MessageRoute route) where TData : LabFusion.Network.Serialization.INetSerializable
		{
			using NetWriter netWriter = NetWriter.Create(data.GetSize());
			data.Serialize(netWriter);
			byte? sender = ((route.Type == RelayType.None) ? null : new byte?(PlayerIDManager.LocalSmallID));
			using NetMessage message = NetMessage.Create(tag, netWriter, route, sender);
			Relay(message, route, sender);
		}

		public static void RelayModule<TMessage, TData>(TData data, MessageRoute route) where TMessage : ModuleMessageHandler where TData : LabFusion.Network.Serialization.INetSerializable
		{
			using NetWriter netWriter = NetWriter.Create(data.GetSize());
			data.Serialize(netWriter);
			byte? sender = ((route.Type == RelayType.None) ? null : new byte?(PlayerIDManager.LocalSmallID));
			using NetMessage message = NetMessage.ModuleCreate<TMessage>(netWriter, route, sender);
			Relay(message, route, sender);
		}

		private static void Relay(NetMessage message, MessageRoute route, byte? sender = null)
		{
			RelayType type = route.Type;
			NetworkChannel channel = route.Channel;
			switch (type)
			{
			case RelayType.None:
			case RelayType.ToServer:
				MessageSender.SendToServer(channel, message);
				break;
			case RelayType.ToClients:
				if (NetworkInfo.IsHost)
				{
					MessageSender.BroadcastMessage(channel, message);
				}
				else
				{
					MessageSender.SendToServer(channel, message);
				}
				break;
			case RelayType.ToOtherClients:
				if (NetworkInfo.IsHost)
				{
					MessageSender.BroadcastMessageExcept(sender.Value, channel, message, ignoreHost: false);
				}
				else
				{
					MessageSender.SendToServer(channel, message);
				}
				break;
			case RelayType.ToTarget:
				if (NetworkInfo.IsHost)
				{
					MessageSender.SendFromServer(route.Target.Value, channel, message);
				}
				else
				{
					MessageSender.SendToServer(channel, message);
				}
				break;
			case RelayType.ToTargets:
				if (NetworkInfo.IsHost)
				{
					foreach (byte target in route.Targets)
					{
						MessageSender.SendFromServer(target, channel, message);
					}
					break;
				}
				MessageSender.SendToServer(channel, message);
				break;
			}
		}
	}
	public static class MessageSender
	{
		public static void SendFromServer(byte userId, NetworkChannel channel, NetMessage message)
		{
			if (message != null && NetworkLayerManager.Layer != null)
			{
				NetworkInfo.BytesUp += message.Length;
				NetworkLayerManager.Layer.SendFromServer(userId, channel, message);
			}
		}

		public static void SendFromServer(ulong userId, NetworkChannel channel, NetMessage message)
		{
			if (message != null && NetworkLayerManager.Layer != null)
			{
				NetworkInfo.BytesUp += message.Length;
				NetworkLayerManager.Layer.SendFromServer(userId, channel, message);
			}
		}

		public unsafe static void SendToServer(NetworkChannel channel, NetMessage message)
		{
			if (message != null && NetworkLayerManager.Layer != null)
			{
				NetworkInfo.BytesUp += message.Length;
				if (!NetworkInfo.IsHost)
				{
					NetworkLayerManager.Layer.SendToServer(channel, message);
					return;
				}
				ulong localPlatformID = PlayerIDManager.LocalPlatformID;
				ReadableMessage message2 = default(ReadableMessage);
				message2.Buffer = new ReadOnlySpan<byte>(message.Buffer, message.Length);
				message2.IsServerHandled = true;
				message2.PlatformID = localPlatformID;
				NativeMessageHandler.ReadMessage(message2);
			}
		}

		public unsafe static void BroadcastMessage(NetworkChannel channel, NetMessage message)
		{
			if (message != null && NetworkLayerManager.Layer != null)
			{
				NetworkInfo.BytesUp += message.Length;
				NetworkLayerManager.Layer.BroadcastMessage(channel, message);
				if (!NetworkInfo.ServerCanSendToHost && NetworkInfo.IsHost)
				{
					ulong localPlatformID = PlayerIDManager.LocalPlatformID;
					ReadableMessage message2 = default(ReadableMessage);
					message2.Buffer = new ReadOnlySpan<byte>(message.Buffer, message.Length);
					message2.IsServerHandled = false;
					message2.PlatformID = localPlatformID;
					NativeMessageHandler.ReadMessage(message2);
				}
			}
		}

		public unsafe static void BroadcastMessageExcept(byte userId, NetworkChannel channel, NetMessage message, bool ignoreHost = true)
		{
			if (message != null && NetworkLayerManager.Layer != null)
			{
				NetworkInfo.BytesUp += message.Length;
				NetworkLayerManager.Layer.BroadcastMessageExcept(userId, channel, message, ignoreHost);
				if (!ignoreHost && userId != PlayerIDManager.LocalSmallID && !NetworkInfo.ServerCanSendToHost && NetworkInfo.IsHost)
				{
					ulong localPlatformID = PlayerIDManager.LocalPlatformID;
					ReadableMessage message2 = default(ReadableMessage);
					message2.Buffer = new ReadOnlySpan<byte>(message.Buffer, message.Length);
					message2.IsServerHandled = false;
					message2.PlatformID = localPlatformID;
					NativeMessageHandler.ReadMessage(message2);
				}
			}
		}

		public unsafe static void BroadcastMessageExcept(ulong userId, NetworkChannel channel, NetMessage message, bool ignoreHost = true)
		{
			if (message != null && NetworkLayerManager.Layer != null)
			{
				NetworkInfo.BytesUp += message.Length;
				NetworkLayerManager.Layer.BroadcastMessageExcept(userId, channel, message, ignoreHost);
				if (!ignoreHost && userId != PlayerIDManager.LocalPlatformID && !NetworkInfo.ServerCanSendToHost && NetworkInfo.IsHost)
				{
					ulong localPlatformID = PlayerIDManager.LocalPlatformID;
					ReadableMessage message2 = default(ReadableMessage);
					message2.Buffer = new ReadOnlySpan<byte>(message.Buffer, message.Length);
					message2.IsServerHandled = false;
					message2.PlatformID = localPlatformID;
					NativeMessageHandler.ReadMessage(message2);
				}
			}
		}

		public static void BroadcastMessageExceptSelf(NetworkChannel channel, NetMessage message)
		{
			if (message != null)
			{
				if (NetworkInfo.IsHost)
				{
					BroadcastMessageExcept(0, channel, message);
				}
				else
				{
					BroadcastMessage(channel, message);
				}
			}
		}
	}
	public static class MetadataHelper
	{
		public static bool TryGetPermissionLevel(this PlayerID id, out PermissionLevel level)
		{
			if (Enum.TryParse<PermissionLevel>(id.Metadata.PermissionLevel.GetValue(), out var result))
			{
				level = result;
				return true;
			}
			level = PermissionLevel.DEFAULT;
			return false;
		}

		public static bool TryGetDisplayName(this PlayerID id, out string name)
		{
			string valueOrEmpty = id.Metadata.Username.GetValueOrEmpty();
			string valueOrEmpty2 = id.Metadata.Nickname.GetValueOrEmpty();
			valueOrEmpty = TextFilter.FilterCommonAndRichText(valueOrEmpty);
			valueOrEmpty2 = TextFilter.FilterCommon(valueOrEmpty2);
			if (TrustedListManager.VerifyPlayer(id.PlatformID, valueOrEmpty) == TrustedStatus.Impersonator)
			{
				valueOrEmpty += " (FAKE)";
			}
			if (TrustedListManager.VerifyPlayer(id.PlatformID, valueOrEmpty2) == TrustedStatus.Impersonator)
			{
				valueOrEmpty2 += " (FAKE)";
			}
			if (!string.IsNullOrWhiteSpace(valueOrEmpty2))
			{
				switch (ClientSettings.NicknameVisibility.Value)
				{
				default:
					name = "~" + valueOrEmpty2;
					break;
				case NicknameVisibility.SHOW:
					name = valueOrEmpty2;
					break;
				case NicknameVisibility.HIDE:
					name = valueOrEmpty;
					break;
				}
			}
			else
			{
				name = valueOrEmpty;
			}
			name = name.LimitLength(32);
			return !string.IsNullOrWhiteSpace(name);
		}
	}
	public static class Net
	{
		[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
		public abstract class NetAttribute : Attribute
		{
			public virtual void OnHandleBegin()
			{
			}

			public virtual bool StopHandling()
			{
				return false;
			}

			public virtual bool IsAwaitable()
			{
				return false;
			}

			public virtual void HookComplete(Action action)
			{
				action();
			}
		}

		[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
		public class DelayWhileLoading : NetAttribute
		{
			public override bool IsAwaitable()
			{
				return true;
			}

			public override void HookComplete(Action action)
			{
				FusionSceneManager.HookOnLevelLoad(action);
			}
		}

		[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
		public class DelayWhileTargetLoading : NetAttribute
		{
			public override bool IsAwaitable()
			{
				return true;
			}

			public override void HookComplete(Action action)
			{
				FusionSceneManager.HookOnTargetLevelLoad(action);
			}
		}

		[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
		public class SkipHandleWhileLoading : NetAttribute
		{
			public override bool StopHandling()
			{
				return FusionSceneManager.IsLoading();
			}
		}
	}
	public static class NetworkHelper
	{
		public static void StartServer()
		{
			NetworkLayerManager.Layer?.StartServer();
		}

		public static void Disconnect(string reason = "")
		{
			NetworkLayerManager.Layer?.Disconnect(reason);
		}

		public static void JoinServerByCode(string code)
		{
			NetworkLayerManager.Layer?.JoinServerByCode(code);
		}

		public static string GetServerCode()
		{
			return NetworkLayerManager.Layer?.GetServerCode();
		}

		public static void RefreshServerCode()
		{
			NetworkLayerManager.Layer.RefreshServerCode();
		}

		public static bool IsFriend(ulong userId)
		{
			if (NetworkLayerManager.Layer != null)
			{
				return NetworkLayerManager.Layer.IsFriend(userId);
			}
			return false;
		}

		public static void KickUser(PlayerID id)
		{
			if (MasterPermissionsManager.IsMaster(id))
			{
				if (!id.TryGetDisplayName(out var name))
				{
					name = "Wacky Willy";
				}
				Notifier.Send(new Notification
				{
					Title = "Failed to Kick User",
					Message = name + " has denied your kick request.",
					SaveToMenu = false,
					ShowPopup = true,
					Type = NotificationType.ERROR
				});
			}
			else
			{
				ConnectionSender.SendDisconnect(id, "Kicked from Server");
			}
		}

		public static void BanUser(PlayerID id)
		{
			if (MasterPermissionsManager.IsMaster(id))
			{
				if (!id.TryGetDisplayName(out var name))
				{
					name = "Wacky Willy";
				}
				Notifier.Send(new Notification
				{
					Title = "Failed to Ban User",
					Message = name + " has denied your ban request.",
					SaveToMenu = false,
					ShowPopup = true,
					Type = NotificationType.ERROR
				});
			}
			else
			{
				BanManager.Ban(new PlayerInfo(id), "Banned");
				ConnectionSender.SendDisconnect(id, "Banned from Server");
			}
		}

		public static bool IsBanned(ulong longID)
		{
			if (MasterPermissionsManager.IsMaster(longID))
			{
				return false;
			}
			foreach (BanInfo ban in BanManager.BanList.Bans)
			{
				if (ban.Player.PlatformID == longID)
				{
					return true;
				}
			}
			return false;
		}

		public static void PardonUser(ulong longId)
		{
			BanManager.Pardon(longId);
		}
	}
	public static class NetworkInfo
	{
		public static NetworkLayer Layer => NetworkLayerManager.Layer;

		public static string Platform
		{
			get
			{
				if (!HasLayer)
				{
					return "None";
				}
				return Layer.Platform;
			}
		}

		public static bool HasLayer => NetworkLayerManager.HasLayer;

		public static INetworkLobby Lobby => Layer.Lobby;

		public static bool HasServer
		{
			get
			{
				if (HasLayer)
				{
					if (!Layer.IsHost)
					{
						return Layer.IsClient;
					}
					return true;
				}
				return false;
			}
		}

		public static bool IsHost
		{
			get
			{
				if (HasLayer)
				{
					return Layer.IsHost;
				}
				return false;
			}
		}

		public static bool IsClient
		{
			get
			{
				if (HasLayer && Layer.IsClient)
				{
					return !Layer.IsHost;
				}
				return false;
			}
		}

		public static bool ServerCanSendToHost
		{
			get
			{
				if (HasLayer)
				{
					return Layer.ServerCanSendToHost;
				}
				return false;
			}
		}

		public static int BytesDown { get; internal set; }

		public static int BytesUp { get; internal set; }
	}
	public enum VersionResult
	{
		Unknown,
		Ok,
		Lower,
		Higher
	}
	public static class NetworkVerification
	{
		public static VersionResult CompareVersion(Version server, Version user)
		{
			server = new Version(server.Major, server.Minor, 0);
			user = new Version(user.Major, user.Minor, 0);
			if (server < user)
			{
				return VersionResult.Lower;
			}
			if (server > user)
			{
				return VersionResult.Higher;
			}
			return VersionResult.Ok;
		}

		public static bool IsClientApproved(ulong platformID)
		{
			switch (SavedServerSettings.Privacy.Value)
			{
			case ServerPrivacy.PUBLIC:
			case ServerPrivacy.PRIVATE:
				return true;
			case ServerPrivacy.FRIENDS_ONLY:
				return NetworkHelper.IsFriend(platformID);
			default:
				return false;
			}
		}

		public static bool HasAuthorityOverPlayer(byte playerID, byte? senderID)
		{
			if (!senderID.HasValue)
			{
				return false;
			}
			byte value = senderID.Value;
			bool flag = value == 0;
			bool flag2 = value == playerID;
			return flag || flag2;
		}
	}
	public static class InternalLayerHelpers
	{
		public static void OnUpdateLayer()
		{
			NetworkLayerManager.Layer?.OnUpdateLayer();
		}

		public static void OnLateUpdateLayer()
		{
			NetworkLayerManager.Layer?.OnLateUpdateLayer();
		}

		public static void OnUserJoin(PlayerID id)
		{
			NetworkLayerManager.Layer?.OnUserJoin(id);
		}
	}
	public static class InternalServerHelpers
	{
		private static void DisposeUser(PlayerID id)
		{
			id?.Cleanup();
		}

		private static void DisposeUsers()
		{
			foreach (PlayerID item in PlayerIDManager.PlayerIDs.ToList())
			{
				DisposeUser(item);
			}
		}

		public static void OnStartServer()
		{
			LocalPlayer.InvokeApplyInitialMetadata();
			new PlayerID(PlayerIDManager.LocalPlatformID, 0, LocalPlayer.Metadata.Metadata.LocalDictionary, GetInitialEquippedItems()).Insert();
			PlayerIDManager.ApplyLocalID();
			NetworkPlayerManager.CreateLocalPlayer();
			MultiplayerHooking.InvokeOnStartedServer();
			NetworkNotifications.SendStartedServerNotification();
			if (AchievementManager.TryGetAchievement<HeadOfHouse>(out var achievement))
			{
				achievement.IncrementTask();
			}
			SceneStreamer.Reload();
		}

		public static void OnJoinServer()
		{
			FusionPreferences.SendClientSettings();
			MultiplayerHooking.InvokeOnJoinedServer();
			NetworkNotifications.SendJoinedServerNotification();
			if (AchievementManager.TryGetAchievement<WarmWelcome>(out var achievement))
			{
				achievement.IncrementTask();
			}
		}

		public static void OnDisconnect(string reason = "")
		{
			DisposeUsers();
			NetworkEntityManager.OnCleanupEntities();
			MultiplayerHooking.InvokeOnDisconnected();
			NetworkNotifications.SendDisconnectedNotification(reason);
		}

		public static void OnPlayerJoined(PlayerID id, bool isInitialJoin)
		{
			FusionPreferences.SendClientSettings();
			InternalLayerHelpers.OnUserJoin(id);
			MultiplayerHooking.InvokeOnPlayerJoined(id);
			if (isInitialJoin && id.TryGetDisplayName(out var name))
			{
				NetworkNotifications.SendPlayerJoinedNotification(name);
			}
		}

		public static void OnPlayerLeft(ulong longId)
		{
			PlayerID playerID = PlayerIDManager.GetPlayerID(longId);
			if (playerID != null)
			{
				if (playerID.TryGetDisplayName(out var name))
				{
					NetworkNotifications.SendPlayerLeftNotification(name);
				}
				DisposeUser(playerID);
				MultiplayerHooking.InvokeOnPlayerLeft(playerID);
			}
		}

		public static List<string> GetInitialEquippedItems()
		{
			List<string> list = new List<string>();
			foreach (PointItem loadedItem in PointItemManager.LoadedItems)
			{
				if (loadedItem.IsEquipped)
				{
					list.Add(loadedItem.Barcode);
				}
			}
			return list;
		}
	}
	public enum ServerPrivacy
	{
		PUBLIC,
		PRIVATE,
		FRIENDS_ONLY,
		LOCKED
	}
	public abstract class NetworkLayer
	{
		private Type _type;

		private bool _hasType;

		public static readonly List<NetworkLayer> Layers = new List<NetworkLayer>();

		public static readonly Dictionary<string, NetworkLayer> LayerLookup = new Dictionary<string, NetworkLayer>();

		public static readonly List<NetworkLayer> SupportedLayers = new List<NetworkLayer>();

		public Type Type
		{
			get
			{
				if (!_hasType)
				{
					_type = GetType();
					_hasType = true;
				}
				return _type;
			}
		}

		public virtual string Title => Type.AssemblyQualifiedName;

		public abstract string Platform { get; }

		public virtual bool IsHost => false;

		public virtual bool IsClient => false;

		public virtual bool ServerCanSendToHost => true;

		public virtual INetworkLobby Lobby => null;

		public virtual IVoiceManager VoiceManager => null;

		public virtual IMatchmaker Matchmaker => null;

		public static event Action<NetworkLayer> OnLoggedInEvent;

		public static event Action<NetworkLayer> OnLoggedOutEvent;

		public abstract bool CheckSupported();

		public abstract bool CheckValidation();

		public virtual bool TryGetFallback(out NetworkLayer fallback)
		{
			fallback = null;
			return false;
		}

		public abstract void StartServer();

		public abstract void Disconnect(string reason = "");

		public abstract void DisconnectUser(ulong platformID);

		public virtual string GetUsername(ulong userId)
		{
			return "Unknown";
		}

		public virtual bool IsFriend(ulong userId)
		{
			return false;
		}

		public virtual void SendFromServer(byte userId, NetworkChannel channel, NetMessage message)
		{
		}

		public virtual void SendFromServer(ulong userId, NetworkChannel channel, NetMessage message)
		{
		}

		public virtual void SendToServer(NetworkChannel channel, NetMessage message)
		{
		}

		public virtual void BroadcastMessage(NetworkChannel channel, NetMessage message)
		{
		}

		public virtual void BroadcastMessageExcept(byte userId, NetworkChannel channel, NetMessage message, bool ignoreHost = true)
		{
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				if (playerID.SmallID != userId && (playerID.SmallID != 0 || !ignoreHost))
				{
					SendFromServer(playerID.SmallID, channel, message);
				}
			}
		}

		public virtual void BroadcastMessageExcept(ulong userId, NetworkChannel channel, NetMessage message, bool ignoreHost = true)
		{
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				if (playerID.PlatformID != userId && (playerID.SmallID != 0 || !ignoreHost))
				{
					SendFromServer(playerID.SmallID, channel, message);
				}
			}
		}

		public abstract void OnInitializeLayer();

		public abstract void OnDeinitializeLayer();

		public abstract void LogIn();

		public abstract void LogOut();

		protected void InvokeLoggedInEvent()
		{
			NetworkLayer.OnLoggedInEvent?.Invoke(this);
		}

		protected void InvokeLoggedOutEvent()
		{
			NetworkLayer.OnLoggedOutEvent?.Invoke(this);
		}

		public virtual void OnUpdateLayer()
		{
		}

		public virtual void OnLateUpdateLayer()
		{
		}

		public virtual void OnUserJoin(PlayerID id)
		{
		}

		public virtual string GetServerCode()
		{
			return null;
		}

		public virtual void RefreshServerCode()
		{
		}

		public virtual void JoinServerByCode(string code)
		{
			throw new NotImplementedException("The current NetworkLayer does not support joining by code!");
		}

		public static void RegisterLayersFromAssembly(Assembly targetAssembly)
		{
			if (targetAssembly == null)
			{
				throw new NullReferenceException("Can't register from a null assembly!");
			}
			AssemblyUtilities.LoadAllValid<NetworkLayer>(targetAssembly, RegisterLayer);
		}

		public static void RegisterLayer<T>() where T : NetworkLayer
		{
			RegisterLayer(typeof(T));
		}

		private static void RegisterLayer(Type type)
		{
			NetworkLayer networkLayer = Activator.CreateInstance(type) as NetworkLayer;
			if (string.IsNullOrWhiteSpace(networkLayer.Title))
			{
				FusionLogger.Warn("Didn't register " + type.Name + " because its Title was invalid!");
				return;
			}
			if (LayerLookup.ContainsKey(networkLayer.Title))
			{
				throw new Exception(type.Name + " has the same Title as " + LayerLookup[networkLayer.Title].GetType().Name + ", we can't replace layers!");
			}
			Layers.Add(networkLayer);
			LayerLookup.Add(networkLayer.Title, networkLayer);
			if (networkLayer.CheckSupported())
			{
				SupportedLayers.Add(networkLayer);
			}
		}

		public static bool TryGetLayer<T>(out T layer) where T : NetworkLayer
		{
			layer = GetLayer<T>();
			return layer != null;
		}

		public static T GetLayer<T>() where T : NetworkLayer
		{
			return (T)Layers.Find((NetworkLayer l) => l.Type == typeof(T));
		}
	}
	public static class NetworkLayerDeterminer
	{
		public static NetworkLayer LoadedLayer { get; private set; }

		public static string LoadedTitle { get; private set; }

		public static NetworkLayer GetDefaultLayer()
		{
			if (PlatformHelper.IsAndroid)
			{
				return NetworkLayer.GetLayer<ProxySteamVRNetworkLayer>();
			}
			return NetworkLayer.GetLayer<SteamVRNetworkLayer>();
		}

		public static NetworkLayer VerifyLayer(NetworkLayer layer)
		{
			if (layer.CheckSupported() && layer.CheckValidation())
			{
				return layer;
			}
			if (layer.TryGetFallback(out var fallback))
			{
				return VerifyLayer(fallback);
			}
			return NetworkLayer.GetLayer<EmptyNetworkLayer>();
		}

		public static void LoadLayer()
		{
			string value = ClientSettings.NetworkLayerTitle.Value;
			if (!NetworkLayer.LayerLookup.TryGetValue(value, out var value2))
			{
				value2 = GetDefaultLayer();
			}
			value2 = (LoadedLayer = VerifyLayer(value2));
			LoadedTitle = value2.Title;
		}
	}
	public static class NetworkLayerManager
	{
		private static bool _loggedIn;

		public static NetworkLayer Layer { get; private set; }

		public static bool HasLayer => Layer != null;

		public static bool LoggedIn
		{
			get
			{
				return _loggedIn;
			}
			private set
			{
				_loggedIn = value;
				NetworkLayerManager.OnLoggedInChanged?.Invoke(value);
			}
		}

		public static event Action<bool> OnLoggedInChanged;

		internal static void OnInitializeMelon()
		{
			NetworkLayer.OnLoggedInEvent += OnLoggedIn;
			NetworkLayer.OnLoggedOutEvent += OnLoggedOut;
		}

		public static NetworkLayer GetTargetLayer()
		{
			NetworkLayerDeterminer.LoadLayer();
			return NetworkLayerDeterminer.LoadedLayer;
		}

		public static void LogIn(NetworkLayer layer)
		{
			layer.LogIn();
		}

		public static void LogOut()
		{
			if (Layer != null)
			{
				Layer.LogOut();
			}
		}

		private static void OnLoggedIn(NetworkLayer layer)
		{
			NetworkLayer layer2 = Layer;
			if (layer2 != null && layer2 != layer)
			{
				Layer = null;
				layer2.LogOut();
			}
			Layer = layer;
			layer.OnInitializeLayer();
			LoggedIn = true;
		}

		private static void OnLoggedOut(NetworkLayer layer)
		{
			layer.OnDeinitializeLayer();
			if (Layer == layer)
			{
				Layer = null;
				LoggedIn = false;
			}
		}
	}
	public class SteamConnectionManager : ConnectionManager
	{
		public override void OnConnected(ConnectionInfo info)
		{
			base.OnConnected(info);
		}

		public override void OnConnecting(ConnectionInfo info)
		{
			base.OnConnecting(info);
		}

		public override void OnDisconnected(ConnectionInfo info)
		{
			base.OnDisconnected(info);
			NetworkHelper.Disconnect();
		}

		public override void OnMessage(IntPtr data, int size, long messageNum, long recvTime, int channel)
		{
			base.OnMessage(data, size, messageNum, recvTime, channel);
			SteamId steamId = base.ConnectionInfo.Identity.SteamId;
			ulong? platformID = (steamId.IsValid ? new ulong?(steamId.Value) : null);
			SteamSocketHandler.OnSocketMessageReceived(data, size, isServerHandled: false, platformID);
		}
	}
	public class SteamLobby : NetworkLobby
	{
		private Lobby _lobby;

		public SteamLobby(Lobby lobby)
		{
			_lobby = lobby;
		}

		public override void SetMetadata(string key, string value)
		{
			if (value == null)
			{
				value = string.Empty;
			}
			_lobby.SetData(key, value);
			SaveKey(key);
		}

		public override bool TryGetMetadata(string key, out string value)
		{
			value = _lobby.GetData(key);
			return !string.IsNullOrWhiteSpace(value);
		}

		public override string GetMetadata(string key)
		{
			return _lobby.GetData(key);
		}

		public override Action CreateJoinDelegate(ulong lobbyId)
		{
			NetworkLayer layer = NetworkLayerManager.Layer;
			SteamNetworkLayer steamLayer = layer as SteamNetworkLayer;
			if (steamLayer != null)
			{
				return delegate
				{
					steamLayer.JoinServer(lobbyId);
				};
			}
			return null;
		}
	}
	public sealed class SteamMatchmaker : IMatchmaker
	{
		private delegate Task<Lobby[]> LobbySearchDelegate(MatchmakerFilters filters);

		[CompilerGenerated]
		private sealed class <FindLobbies>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LobbySearchDelegate searchDelegate;

			public MatchmakerFilters filters;

			public Action<IMatchmaker.MatchmakerCallbackInfo> callback;

			private Task<Lobby[]> <task>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <FindLobbies>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<task>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<task>5__2 = searchDelegate(filters);
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (!<task>5__2.IsCompleted)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if (!<task>5__2.IsCompletedSuccessfully)
				{
					FusionLogger.LogException("searching for lobbies", <task>5__2.Exception);
					callback?.Invoke(IMatchmaker.MatchmakerCallbackInfo.Empty);
					return false;
				}
				Lobby[] result = <task>5__2.Result;
				if (result == null)
				{
					callback?.Invoke(IMatchmaker.MatchmakerCallbackInfo.Empty);
					return false;
				}
				List<IMatchmaker.LobbyInfo> list = new List<IMatchmaker.LobbyInfo>();
				Lobby[] array = result;
				for (int i = 0; i < array.Length; i++)
				{
					Lobby lobby = array[i];
					if (!lobby.Owner.IsMe)
					{
						SteamLobby lobby2 = new SteamLobby(lobby);
						LobbyMetadataInfo metadata = LobbyMetadataSerializer.ReadInfo(lobby2);
						if (metadata.HasLobbyOpen)
						{
							list.Add(new IMatchmaker.LobbyInfo
							{
								Lobby = lobby2,
								Metadata = metadata
							});
						}
					}
				}
				IMatchmaker.MatchmakerCallbackInfo matchmakerCallbackInfo = default(IMatchmaker.MatchmakerCallbackInfo);
				matchmakerCallbackInfo.Lobbies = list.ToArray();
				IMatchmaker.MatchmakerCallbackInfo obj = matchmakerCallbackInfo;
				callback?.Invoke(obj);
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public void RequestLobbies(Action<IMatchmaker.MatchmakerCallbackInfo> callback)
		{
			RequestLobbies(MatchmakerFilters.Empty, callback);
		}

		public void RequestLobbies(MatchmakerFilters filters, Action<IMatchmaker.MatchmakerCallbackInfo> callback)
		{
			MelonCoroutines.Start(FindLobbies(FetchLobbies, filters, callback));
		}

		public void RequestLobbiesByCode(string code, Action<IMatchmaker.MatchmakerCallbackInfo> callback)
		{
			MelonCoroutines.Start(FindLobbies(FetchLobbies, MatchmakerFilters.Empty, callback));
			Task<Lobby[]> FetchLobbies(MatchmakerFilters filters)
			{
				return FetchLobbiesByCode(code);
			}
		}

		[IteratorStateMachine(typeof(<FindLobbies>d__4))]
		private static IEnumerator FindLobbies(LobbySearchDelegate searchDelegate, MatchmakerFilters filters, Action<IMatchmaker.MatchmakerCallbackInfo> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FindLobbies>d__4(0)
			{
				searchDelegate = searchDelegate,
				filters = filters,
				callback = callback
			};
		}

		private static Task<Lobby[]> FetchLobbies(MatchmakerFilters filters)
		{
			LobbyQuery lobbyList = SteamMatchmaking.LobbyList;
			lobbyList = AddPersistentFilters(lobbyList);
			return AddMatchmakingFilters(lobbyList, filters).WithNotEqual("Privacy", 1).WithNotEqual("Privacy", 3).RequestAsync();
		}

		private static Task<Lobby[]> FetchLobbiesByCode(string code)
		{
			LobbyQuery lobbyList = SteamMatchmaking.LobbyList;
			return AddPersistentFilters(lobbyList).WithKeyValue("LobbyCode", code.ToUpper()).RequestAsync();
		}

		private static LobbyQuery AddPersistentFilters(LobbyQuery query)
		{
			return query.FilterDistanceWorldwide().WithKeyValue("MarrowFusion", bool.TrueString).WithKeyValue("HasLobbyOpen", bool.TrueString)
				.WithKeyValue("Game", LabFusion.Support.GameInfo.GameName);
		}

		private static LobbyQuery AddMatchmakingFilters(LobbyQuery query, MatchmakerFilters filters)
		{
			if (filters.FilterFull)
			{
				query = query.WithKeyValue("Full", bool.FalseString);
			}
			if (filters.FilterMismatchingVersions)
			{
				Version version = FusionMod.Version;
				int major = version.Major;
				int minor = version.Minor;
				query = query.WithEqual("VersionMajor", major).WithEqual("VersionMinor", minor);
			}
			return query;
		}
	}
	public abstract class SteamNetworkLayer : NetworkLayer
	{
		public const int ReceiveBufferSize = 32;

		private INetworkLobby _currentLobby;

		private IVoiceManager _voiceManager;

		private IMatchmaker _matchmaker;

		public SteamId SteamId;

		public static SteamSocketManager SteamSocket;

		public static SteamConnectionManager SteamConnection;

		protected bool _isServerActive;

		protected bool _isConnectionActive;

		protected Lobby _localLobby;

		private const string STEAMWORKS_ASSEMBLY_NAME = "Il2CppFacepunch.Steamworks.Win64";

		public abstract uint ApplicationID { get; }

		public override string Title => "Steam";

		public override string Platform => "Steam";

		public override bool IsHost => _isServerActive;

		public override bool IsClient => _isConnectionActive;

		public override INetworkLobby Lobby => _currentLobby;

		public override IVoiceManager VoiceManager => _voiceManager;

		public override IMatchmaker Matchmaker => _matchmaker;

		public string ServerCode { get; private set; }

		public override bool CheckSupported()
		{
			return !PlatformHelper.IsAndroid;
		}

		public override bool CheckValidation()
		{
			return SteamAPILoader.HasSteamAPI;
		}

		public override void OnInitializeLayer()
		{
			if (!SteamClient.IsValid)
			{
				FusionLogger.Error("Steamworks failed to initialize!");
				return;
			}
			SteamId = SteamClient.SteamId;
			PlayerIDManager.SetLongID(SteamId.Value);
			LocalPlayer.Username = GetUsername(SteamId.Value);
			FusionLogger.Log($"Steamworks initialized with SteamID {SteamId} and ApplicationID {ApplicationID}!");
			SteamNetworkingUtils.InitRelayNetworkAccess();
			HookSteamEvents();
			_voiceManager = new UnityVoiceManager();
			_voiceManager.Enable();
			_matchmaker = new SteamMatchmaker();
		}

		public override void OnDeinitializeLayer()
		{
			_voiceManager.Disable();
			_voiceManager = null;
			_matchmaker = null;
			_localLobby = default(Lobby);
			_currentLobby = null;
			Disconnect();
			UnHookSteamEvents();
			SteamAPI.Shutdown();
		}

		public override void LogIn()
		{
			if (!SteamClient.IsValid)
			{
				if (GameHasSteamworks())
				{
					ShutdownGameClient();
				}
				bool flag;
				try
				{
					SteamClient.Init(ApplicationID, asyncCallbacks: false);
					flag = true;
				}
				catch (Exception e)
				{
					FusionLogger.LogException("initializing Steamworks", e);
					flag = false;
				}
				if (!flag)
				{
					Notifier.Send(new Notification
					{
						Title = "Log In Failed",
						Message = "Failed connecting to Steamworks! Make sure Steam is running and signed in!",
						SaveToMenu = false,
						ShowPopup = true,
						Type = NotificationType.ERROR,
						PopupLength = 6f
					});
					InvokeLoggedOutEvent();
				}
				else
				{
					InvokeLoggedInEvent();
				}
			}
		}

		public override void LogOut()
		{
			SteamClient.Shutdown();
			InvokeLoggedOutEvent();
		}

		private static bool GameHasSteamworks()
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				if (assemblies[i].FullName.StartsWith("Il2CppFacepunch.Steamworks.Win64"))
				{
					return true;
				}
			}
			return false;
		}

		private static void ShutdownGameClient()
		{
			FusionLogger.Log("Shutting down the game's Steamworks instance...");
			SteamClient.Shutdown();
		}

		public override void OnUpdateLayer()
		{
			SteamClient.RunCallbacks();
			try
			{
				SteamSocket?.Receive();
				SteamConnection?.Receive();
			}
			catch (Exception e)
			{
				FusionLogger.LogException("receiving data on Socket and Connection", e);
			}
		}

		public override string GetUsername(ulong userId)
		{
			return new Friend(userId).Name;
		}

		public override bool IsFriend(ulong userId)
		{
			if (userId != PlayerIDManager.LocalPlatformID)
			{
				return new Friend(userId).IsFriend;
			}
			return true;
		}

		public override void BroadcastMessage(NetworkChannel channel, NetMessage message)
		{
			if (IsHost)
			{
				SteamSocket.BroadcastToClients(channel, message);
			}
			else
			{
				SteamSocketHandler.BroadcastToServer(channel, message);
			}
		}

		public override void SendToServer(NetworkChannel channel, NetMessage message)
		{
			SteamSocketHandler.BroadcastToServer(channel, message);
		}

		public override void SendFromServer(byte userId, NetworkChannel channel, NetMessage message)
		{
			PlayerID playerID = PlayerIDManager.GetPlayerID(userId);
			if (playerID != null)
			{
				SendFromServer(playerID.PlatformID, channel, message);
			}
		}

		public override void SendFromServer(ulong userId, NetworkChannel channel, NetMessage message)
		{
			if (IsHost && SteamSocket.ConnectedSteamIDs.TryGetValue(userId, out var value))
			{
				SteamSocket.SendToClient(value, channel, message);
			}
		}

		public override void StartServer()
		{
			SteamSocket = SteamNetworkingSockets.CreateRelaySocket<SteamSocketManager>();
			SteamConnection = SteamNetworkingSockets.ConnectRelay<SteamConnectionManager>(SteamId);
			_isServerActive = true;
			_isConnectionActive = true;
			InternalServerHelpers.OnStartServer();
			RefreshServerCode();
		}

		public void JoinServer(SteamId serverId)
		{
			if (_isConnectionActive || _isServerActive)
			{
				Disconnect();
			}
			SteamConnection = SteamNetworkingSockets.ConnectRelay<SteamConnectionManager>(serverId);
			_isServerActive = false;
			_isConnectionActive = true;
			ConnectionSender.SendConnectionRequest();
		}

		public override void Disconnect(string reason = "")
		{
			if (_isServerActive || _isConnectionActive)
			{
				try
				{
					SteamConnection?.Close();
					SteamSocket?.Close();
				}
				catch
				{
					FusionLogger.Log("Error closing socket server / connection manager");
				}
				_isServerActive = false;
				_isConnectionActive = false;
				InternalServerHelpers.OnDisconnect(reason);
			}
		}

		public override void DisconnectUser(ulong platformID)
		{
			if (_isServerActive)
			{
				SteamSocket.DisconnectUser(platformID);
			}
		}

		public override string GetServerCode()
		{
			return ServerCode;
		}

		public override void RefreshServerCode()
		{
			ServerCode = RandomCodeGenerator.GetString(8);
			LobbyInfoManager.PushLobbyUpdate();
		}

		public override void JoinServerByCode(string code)
		{
			if (Matchmaker == null)
			{
				return;
			}
			Matchmaker.RequestLobbiesByCode(code, delegate(IMatchmaker.MatchmakerCallbackInfo info)
			{
				if (info.Lobbies.Length != 0)
				{
					JoinServer(info.Lobbies[0].Metadata.LobbyInfo.LobbyID);
				}
			});
		}

		private void HookSteamEvents()
		{
			MultiplayerHooking.OnPlayerJoined += OnPlayerJoin;
			MultiplayerHooking.OnPlayerLeft += OnPlayerLeave;
			MultiplayerHooking.OnDisconnected += OnDisconnect;
			LobbyInfoManager.OnLobbyInfoChanged += OnUpdateLobby;
			AwaitLobbyCreation();
		}

		private void OnPlayerJoin(PlayerID id)
		{
			if (VoiceManager != null && !id.IsMe)
			{
				VoiceManager.GetSpeaker(id);
			}
		}

		private void OnPlayerLeave(PlayerID id)
		{
			if (VoiceManager != null)
			{
				VoiceManager.RemoveSpeaker(id);
			}
		}

		private void OnDisconnect()
		{
			if (VoiceManager != null)
			{
				VoiceManager.ClearManager();
			}
		}

		private void UnHookSteamEvents()
		{
			MultiplayerHooking.OnPlayerJoined -= OnPlayerJoin;
			MultiplayerHooking.OnPlayerLeft -= OnPlayerLeave;
			MultiplayerHooking.OnDisconnected -= OnDisconnect;
			LobbyInfoManager.OnLobbyInfoChanged -= OnUpdateLobby;
			if ((ulong)_localLobby.Id == (ulong)SteamId)
			{
				_localLobby.Leave();
			}
		}

		private async void AwaitLobbyCreation()
		{
			Lobby? lobby = await SteamMatchmaking.CreateLobbyAsync();
			if (lobby.HasValue)
			{
				_localLobby = lobby.Value;
				_currentLobby = new SteamLobby(_localLobby);
			}
		}

		public void OnUpdateLobby()
		{
			if (Lobby != null)
			{
				LobbyMetadataSerializer.WriteInfo(Lobby);
			}
		}
	}
	public static class SteamSocketHandler
	{
		public static SendType ConvertToSendType(NetworkChannel channel)
		{
			if (channel == NetworkChannel.Reliable)
			{
				return SendType.Reliable;
			}
			return SendType.Unreliable;
		}

		public unsafe static void SendToClient(this SteamSocketManager socketManager, Connection connection, NetworkChannel channel, NetMessage message)
		{
			SendType sendType = ConvertToSendType(channel);
			int length = message.Length;
			connection.SendMessage((IntPtr)message.Buffer, length, sendType);
		}

		public unsafe static void BroadcastToClients(this SteamSocketManager socketManager, NetworkChannel channel, NetMessage message)
		{
			SendType sendType = ConvertToSendType(channel);
			int length = message.Length;
			IntPtr ptr = (IntPtr)message.Buffer;
			foreach (Connection item in socketManager.Connected)
			{
				item.SendMessage(ptr, length, sendType);
			}
		}

		public unsafe static void BroadcastToServer(NetworkChannel channel, NetMessage message)
		{
			try
			{
				SendType sendType = ConvertToSendType(channel);
				int length = message.Length;
				IntPtr ptr = (IntPtr)message.Buffer;
				Connection connection = SteamNetworkLayer.SteamConnection.Connection;
				if (connection.SendMessage(ptr, length, sendType) != Result.OK)
				{
					Result result = connection.SendMessage(ptr, length, sendType);
					if (result != Result.OK)
					{
						throw new Exception($"Steam result was {result}.");
					}
				}
			}
			catch (Exception ex)
			{
				FusionLogger.Error("Failed sending message to socket server with reason: " + ex.Message + "\nTrace:" + ex.StackTrace);
			}
		}

		public unsafe static void OnSocketMessageReceived(IntPtr messageIntPtr, int dataBlockSize, bool isServerHandled = false, ulong? platformID = null)
		{
			try
			{
				ReadOnlySpan<byte> buffer = new ReadOnlySpan<byte>(messageIntPtr.ToPointer(), dataBlockSize);
				ReadableMessage message = default(ReadableMessage);
				message.Buffer = buffer;
				message.IsServerHandled = isServerHandled;
				message.PlatformID = platformID;
				NativeMessageHandler.ReadMessage(message);
			}
			catch (Exception ex)
			{
				FusionLogger.Error("Failed reading message from socket server with reason: " + ex.Message + "\nTrace:" + ex.StackTrace);
			}
		}
	}
	public class SteamSocketManager : SocketManager
	{
		public Dictionary<ulong, Connection> ConnectedSteamIDs = new Dictionary<ulong, Connection>();

		public void DisconnectUser(ulong steamID)
		{
			if (ConnectedSteamIDs.TryGetValue(steamID, out var value))
			{
				value.Close();
			}
		}

		public override void OnConnecting(Connection connection, ConnectionInfo data)
		{
			base.OnConnecting(connection, data);
			connection.Accept();
		}

		public override void OnConnected(Connection connection, ConnectionInfo data)
		{
			base.OnConnected(connection, data);
			if (!ConnectedSteamIDs.ContainsKey(SteamClient.SteamId))
			{
				ConnectedSteamIDs[SteamClient.SteamId] = connection;
			}
		}

		public override void OnDisconnected(Connection connection, ConnectionInfo data)
		{
			base.OnDisconnected(connection, data);
			KeyValuePair<ulong, Connection> keyValuePair = ConnectedSteamIDs.First((KeyValuePair<ulong, Connection> p) => p.Value.Id == connection.Id);
			ulong key = keyValuePair.Key;
			ConnectedSteamIDs.Remove(keyValuePair.Key);
			if (PlayerIDManager.HasPlayerID(key))
			{
				InternalServerHelpers.OnPlayerLeft(keyValuePair.Key);
				ConnectionSender.SendDisconnect(key);
			}
		}

		public override void OnMessage(Connection connection, NetIdentity identity, IntPtr data, int size, long messageNum, long recvTime, int channel)
		{
			base.OnMessage(connection, identity, data, size, messageNum, recvTime, channel);
			ulong steamid = identity.steamid;
			ConnectedSteamIDs[steamid] = connection;
			SteamSocketHandler.OnSocketMessageReceived(data, size, isServerHandled: true, steamid);
		}
	}
	public class SteamVRNetworkLayer : SteamNetworkLayer
	{
		public const int SteamVRId = 250820;

		public override uint ApplicationID => 250820u;

		public override string Title => "SteamVR";
	}
	public interface IMatchmaker
	{
		public struct MatchmakerCallbackInfo
		{
			public static readonly MatchmakerCallbackInfo Empty = new MatchmakerCallbackInfo
			{
				Lobbies = Array.Empty<LobbyInfo>()
			};

			public LobbyInfo[] Lobbies;
		}

		public struct LobbyInfo
		{
			public INetworkLobby Lobby;

			public LobbyMetadataInfo Metadata;
		}

		void RequestLobbies(Action<MatchmakerCallbackInfo> callback);

		void RequestLobbies(MatchmakerFilters filters, Action<MatchmakerCallbackInfo> callback);

		void RequestLobbiesByCode(string code, Action<MatchmakerCallbackInfo> callback);
	}
	public interface INetworkLobby
	{
		void WriteKeyCollection();

		void SetMetadata(string key, string value);

		bool TryGetMetadata(string key, out string value);

		string GetMetadata(string key);

		Action CreateJoinDelegate(ulong lobbyId);
	}
	public abstract class NetworkLobby : INetworkLobby
	{
		private readonly List<string> _keyCollection = new List<string>();

		public void WriteKeyCollection()
		{
			SetMetadata("KeyCollection", _keyCollection.Contract());
		}

		protected void SaveKey(string key)
		{
			if (!(key == "KeyCollection") && !_keyCollection.Contains(key))
			{
				_keyCollection.Add(key);
			}
		}

		public abstract string GetMetadata(string key);

		public abstract void SetMetadata(string key, string value);

		public abstract bool TryGetMetadata(string key, out string value);

		public abstract Action CreateJoinDelegate(ulong lobbyId);
	}
	public static class LobbyKeys
	{
		public const string IdentifierKey = "MarrowFusion";

		public const string HasLobbyOpenKey = "HasLobbyOpen";

		public const string KeyCollectionKey = "KeyCollection";

		public const string LobbyCodeKey = "LobbyCode";

		public const string PrivacyKey = "Privacy";

		public const string FullKey = "Full";

		public const string VersionMajorKey = "VersionMajor";

		public const string VersionMinorKey = "VersionMinor";

		public const string GameKey = "Game";
	}
	public struct LobbyMetadataInfo
	{
		public static readonly LobbyMetadataInfo Empty = new LobbyMetadataInfo
		{
			LobbyInfo = null,
			HasLobbyOpen = false,
			ClientHasLevel = false,
			LobbyCode = null,
			Privacy = ServerPrivacy.PUBLIC,
			Full = false,
			VersionMajor = 0,
			VersionMinor = 0,
			Game = null
		};

		public LobbyInfo LobbyInfo { get; set; }

		public bool HasLobbyOpen { get; set; }

		public bool ClientHasLevel { get; set; }

		public string LobbyCode { get; set; }

		public ServerPrivacy Privacy { get; set; }

		public bool Full { get; set; }

		public int VersionMajor { get; set; }

		public int VersionMinor { get; set; }

		public string Game { get; set; }

		public static LobbyMetadataInfo Create()
		{
			LobbyInfo lobbyInfo = LobbyInfoManager.LobbyInfo;
			if (lobbyInfo == null)
			{
				return Empty;
			}
			LobbyMetadataInfo result = default(LobbyMetadataInfo);
			result.LobbyInfo = lobbyInfo;
			result.HasLobbyOpen = NetworkInfo.IsHost;
			result.LobbyCode = lobbyInfo.LobbyCode;
			result.Privacy = lobbyInfo.Privacy;
			result.Full = lobbyInfo.PlayerCount >= lobbyInfo.MaxPlayers;
			result.VersionMajor = lobbyInfo.LobbyVersion.Major;
			result.VersionMinor = lobbyInfo.LobbyVersion.Minor;
			result.Game = LabFusion.Support.GameInfo.GameName;
			return result;
		}

		public readonly void Write(INetworkLobby lobby)
		{
			lobby.SetMetadata("MarrowFusion", bool.TrueString);
			lobby.SetMetadata("HasLobbyOpen", HasLobbyOpen.ToString());
			lobby.SetMetadata("LobbyCode", LobbyCode?.ToUpper());
			lobby.SetMetadata("Privacy", ((int)Privacy).ToString());
			lobby.SetMetadata("Full", Full.ToString());
			lobby.SetMetadata("VersionMajor", VersionMajor.ToString());
			lobby.SetMetadata("VersionMinor", VersionMinor.ToString());
			lobby.SetMetadata("Game", Game);
			lobby.SetMetadata("LobbyInfo", JsonSerializer.Serialize(LobbyInfo));
			lobby.WriteKeyCollection();
		}

		public static LobbyMetadataInfo Read(INetworkLobby lobby)
		{
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			LobbyMetadataInfo lobbyMetadataInfo = default(LobbyMetadataInfo);
			lobbyMetadataInfo.HasLobbyOpen = lobby.GetMetadata("HasLobbyOpen") == bool.TrueString;
			lobbyMetadataInfo.LobbyCode = lobby.GetMetadata("LobbyCode");
			lobbyMetadataInfo.Game = lobby.GetMetadata("Game");
			lobbyMetadataInfo.Full = lobby.GetMetadata("Full") == bool.TrueString;
			LobbyMetadataInfo result = lobbyMetadataInfo;
			if (lobby.TryGetMetadata("Privacy", out var value) && int.TryParse(value, out var result2))
			{
				result.Privacy = (ServerPrivacy)result2;
			}
			if (lobby.TryGetMetadata("VersionMajor", out var value2) && int.TryParse(value2, out var result3))
			{
				result.VersionMajor = result3;
			}
			if (lobby.TryGetMetadata("VersionMinor", out var value3) && int.TryParse(value3, out var result4))
			{
				result.VersionMinor = result4;
			}
			if (lobby.TryGetMetadata("LobbyInfo", out var value4))
			{
				try
				{
					result.LobbyInfo = JsonSerializer.Deserialize<LobbyInfo>(value4);
				}
				catch
				{
					result.HasLobbyOpen = false;
				}
			}
			else
			{
				result.HasLobbyOpen = false;
			}
			result.ClientHasLevel = CrateFilterer.HasCrate<LevelCrate>(new Barcode(result.LobbyInfo.LevelBarcode));
			return result;
		}

		public readonly Action CreateJoinDelegate(INetworkLobby lobby)
		{
			return lobby.CreateJoinDelegate(LobbyInfo.LobbyID);
		}
	}
	public static class LobbyMetadataSerializer
	{
		public static void WriteInfo(INetworkLobby lobby)
		{
			LobbyMetadataInfo.Create().Write(lobby);
		}

		public static LobbyMetadataInfo ReadInfo(INetworkLobby lobby)
		{
			try
			{
				return LobbyMetadataInfo.Read(lobby);
			}
			catch (Exception)
			{
				LobbyMetadataInfo result = default(LobbyMetadataInfo);
				result.HasLobbyOpen = false;
				return result;
			}
		}
	}
	public struct MatchmakerFilters
	{
		public static readonly MatchmakerFilters Default = new MatchmakerFilters
		{
			FilterFull = true,
			FilterMismatchingVersions = true
		};

		public static readonly MatchmakerFilters Empty = new MatchmakerFilters
		{
			FilterFull = false,
			FilterMismatchingVersions = false
		};

		public bool FilterFull;

		public bool FilterMismatchingVersions;
	}
	public static class LobbyInfoManager
	{
		private static LobbyInfo _lobbyInfo = LobbyInfo.Empty;

		public static LobbyInfo LobbyInfo
		{
			get
			{
				return _lobbyInfo;
			}
			set
			{
				_lobbyInfo = value;
				LobbyInfoManager.OnLobbyInfoChanged.InvokeSafe("executing LobbyInfoManager.OnLobbyInfoChanged");
			}
		}

		public static event Action OnLobbyInfoChanged;

		public static void OnInitialize()
		{
			MultiplayerHooking.OnMainSceneInitialized += PushLobbyUpdate;
			MultiplayerHooking.OnPlayerJoined += delegate
			{
				PushLobbyUpdate();
			};
			MultiplayerHooking.OnPlayerLeft += delegate
			{
				PushLobbyUpdate();
			};
			MultiplayerHooking.OnStartedServer += PushLobbyUpdate;
			MultiplayerHooking.OnDisconnected += PushLobbyUpdate;
			SavedServerSettings.OnSavedServerSettingsChanged += PushLobbyUpdate;
			GamemodeManager.OnGamemodeChanged += delegate
			{
				PushLobbyUpdate();
			};
		}

		public static void PushLobbyUpdate()
		{
			if (NetworkLayerManager.Layer == null)
			{
				LobbyInfo = LobbyInfo.Empty;
			}
			else if (!NetworkInfo.HasServer)
			{
				LobbyInfo = LobbyInfo.Empty;
			}
			else if (!NetworkInfo.IsClient)
			{
				LobbyInfo lobbyInfo = new LobbyInfo();
				lobbyInfo.WriteLobby();
				LobbyInfo = lobbyInfo;
				if (NetworkInfo.IsHost)
				{
					SendLobbyInfo();
				}
			}
		}

		private static void SendLobbyInfo()
		{
			if (NetworkInfo.IsHost)
			{
				MessageRelay.RelayNative(ServerSettingsData.Create(), NativeMessageTag.ServerSettings, CommonMessageRoutes.ReliableToOtherClients);
			}
		}

		internal static void SendLobbyInfo(ulong platformID)
		{
			if (!NetworkInfo.IsHost)
			{
				return;
			}
			using NetWriter netWriter = NetWriter.Create();
			ServerSettingsData value = ServerSettingsData.Create();
			NetSerializerExtensions.SerializeValue(netWriter, ref value);
			using NetMessage message = NetMessage.Create(NativeMessageTag.ServerSettings, netWriter, CommonMessageRoutes.None);
			MessageSender.SendFromServer(platformID, NetworkChannel.Reliable, message);
		}
	}
	public static class CatchupManager
	{
		public static event Action<PlayerID> OnPlayerServerCatchup;

		public static event NetworkEntityPlayerDelegate OnEntityDataCatchup;

		public static void RequestEntityDataCatchup(NetworkEntityReference entityReference)
		{
			if (entityReference.TryGetEntity(out var entity))
			{
				RequestEntityDataCatchup(entity.OwnerID ?? PlayerIDManager.GetHostID(), entityReference);
			}
		}

		public static void RequestEntityDataCatchup(PlayerID ownerID, NetworkEntityReference entityReference)
		{
			if (!ownerID.IsMe)
			{
				MessageRelay.RelayNative(new EntityPlayerData
				{
					PlayerID = PlayerIDManager.LocalSmallID,
					Entity = entityReference
				}, NativeMessageTag.EntityDataRequest, new MessageRoute(ownerID.SmallID, NetworkChannel.Reliable));
			}
		}

		internal static void InvokePlayerServerCatchup(PlayerID playerID)
		{
			CatchupManager.OnPlayerServerCatchup.InvokeSafe(playerID, "executing OnPlayerCatchup hook");
		}

		internal static void InvokeEntityDataCatchup(PlayerID playerID, NetworkEntityReference entityReference)
		{
			if (entityReference.TryGetEntity(out var entity))
			{
				entity.InvokeDataCatchup(playerID);
				CatchupManager.OnEntityDataCatchup?.InvokeSafe(playerID, entity, "executing CatchupManager.OnEntityDataCatchup");
			}
		}
	}
	public static class CommonMessageRoutes
	{
		public static readonly MessageRoute None = new MessageRoute(RelayType.None, NetworkChannel.Reliable);

		public static readonly MessageRoute ReliableToServer = new MessageRoute(RelayType.ToServer, NetworkChannel.Reliable);

		public static readonly MessageRoute ReliableToClients = new MessageRoute(RelayType.ToClients, NetworkChannel.Reliable);

		public static readonly MessageRoute UnreliableToClients = new MessageRoute(RelayType.ToClients, NetworkChannel.Unreliable);

		public static readonly MessageRoute ReliableToOtherClients = new MessageRoute(RelayType.ToOtherClients, NetworkChannel.Reliable);

		public static readonly MessageRoute UnreliableToOtherClients = new MessageRoute(RelayType.ToOtherClients, NetworkChannel.Unreliable);
	}
	public class ModInfoRequestData : LabFusion.Network.Serialization.INetSerializable
	{
		public string Barcode;

		public uint TrackerID;

		public int? GetSize()
		{
			return Barcode.GetSize() + 4;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Barcode);
			serializer.SerializeValue(ref TrackerID);
		}

		public static ModInfoRequestData Create(string barcode, uint trackerID)
		{
			return new ModInfoRequestData
			{
				Barcode = barcode,
				TrackerID = trackerID
			};
		}
	}
	public class ModInfoRequestMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.ModInfoRequest;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			ModInfoRequestData modInfoRequestData = received.ReadData<ModInfoRequestData>();
			if (received.Route.Target != PlayerIDManager.LocalSmallID)
			{
				throw new Exception($"Received a ModInfoRequest, but we were not the desired target of {received.Route.Target.Value}!");
			}
			Crate crate = CrateFilterer.GetCrate<Crate>(new Barcode(modInfoRequestData.Barcode));
			if ((Object)(object)crate == (Object)null)
			{
				return;
			}
			Pallet pallet = crate.Pallet;
			if (pallet.IsInMarrowGame())
			{
				return;
			}
			PalletManifest manifest = CrateFilterer.GetManifest(pallet);
			if (manifest != null)
			{
				ModIOModTarget targetFromListing = ModIOManager.GetTargetFromListing(manifest.ModListing);
				if (targetFromListing != null)
				{
					MessageRelay.RelayNative(ModInfoResponseData.Create(new SerializedModIOFile(new ModIOFile((int)targetFromListing.ModId, (int)targetFromListing.ModfileId)), modInfoRequestData.TrackerID), NativeMessageTag.ModInfoResponse, new MessageRoute(received.Sender.Value, NetworkChannel.Reliable));
				}
			}
		}
	}
	public class ModInfoResponseData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 6;

		public SerializedModIOFile ModFile;

		public uint TrackerID;

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref ModFile);
			serializer.SerializeValue(ref TrackerID);
		}

		public static ModInfoResponseData Create(SerializedModIOFile modFile, uint trackerID)
		{
			return new ModInfoResponseData
			{
				ModFile = modFile,
				TrackerID = trackerID
			};
		}
	}
	public class ModInfoResponseMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.ModInfoResponse;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			ModInfoResponseData modInfoResponseData = received.ReadData<ModInfoResponseData>();
			if (received.Route.Target != PlayerIDManager.LocalSmallID)
			{
				throw new Exception($"Received a ModInfoResponse, but we were not the desired target of {received.Route.Target.Value}!");
			}
			NetworkModRequester.OnResponseReceived(modInfoResponseData.TrackerID, new NetworkModRequester.ModCallbackInfo
			{
				ModFile = modInfoResponseData.ModFile.File,
				HasFile = modInfoResponseData.ModFile.HasFile,
				Platform = modInfoResponseData.ModFile.Platform
			});
		}
	}
	public class EntityCullStatusData : LabFusion.Network.Serialization.INetSerializable
	{
		public NetworkEntityReference Entity;

		public bool IsCulled;

		public int? GetSize()
		{
			return 3;
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref Entity);
			serializer.SerializeValue(ref IsCulled);
		}

		public NetworkEntity GetEntity()
		{
			return Entity.GetEntity();
		}
	}
	[Net.SkipHandleWhileLoading]
	public class EntityCullStatusMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.EntityCullStatus;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			byte? sender = received.Sender;
			if (sender.HasValue)
			{
				EntityCullStatusData entityCullStatusData = received.ReadData<EntityCullStatusData>();
				NetworkEntity entity = entityCullStatusData.GetEntity();
				if (entity != null && entity.IsRegistered && entity.OwnerID != null && (byte)entity.OwnerID == sender.Value)
				{
					entity.GetExtender<NetworkProp>()?.OnReceiveCullStatus(entityCullStatusData.IsCulled);
				}
			}
		}
	}
	public class EntityDataRequestMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.EntityDataRequest;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			EntityPlayerData entityPlayerData = received.ReadData<EntityPlayerData>();
			PlayerID playerID = PlayerIDManager.GetPlayerID(entityPlayerData.PlayerID);
			if (playerID != null)
			{
				CatchupManager.InvokeEntityDataCatchup(playerID, entityPlayerData.Entity);
			}
		}
	}
	public class EntityOwnershipRequestMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.EntityOwnershipRequest;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ServerOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			EntityPlayerData entityPlayerData = received.ReadData<EntityPlayerData>();
			MessageRelay.RelayNative(new EntityPlayerData
			{
				PlayerID = entityPlayerData.PlayerID,
				Entity = new NetworkEntityReference(entityPlayerData.Entity.ID)
			}, NativeMessageTag.EntityOwnershipResponse, CommonMessageRoutes.ReliableToClients);
		}
	}
	public class EntityOwnershipResponseMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.EntityOwnershipResponse;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ClientsOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			EntityPlayerData entityPlayerData = received.ReadData<EntityPlayerData>();
			NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(entityPlayerData.Entity.ID)?.SetOwner(PlayerIDManager.GetPlayerID(entityPlayerData.PlayerID));
		}
	}
	public class EntityPoseUpdateData : LabFusion.Network.Serialization.INetSerializable
	{
		public NetworkEntityReference Entity;

		public EntityPose Pose;

		public int? GetSize()
		{
			return 2 + Pose.GetSize();
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref Entity);
			NetSerializerExtensions.SerializeValue(serializer, ref Pose);
		}

		public NetworkEntity GetEntity()
		{
			return Entity.GetEntity();
		}
	}
	[Net.SkipHandleWhileLoading]
	public class EntityPoseUpdateMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.EntityPoseUpdate;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			EntityPoseUpdateData entityPoseUpdateData = received.ReadData<EntityPoseUpdateData>();
			NetworkEntity entity = entityPoseUpdateData.GetEntity();
			if (entity != null && entity.IsRegistered && entity.OwnerID != null && (byte)entity.OwnerID == received.Sender)
			{
				entity.GetExtender<NetworkProp>()?.OnReceivePose(entityPoseUpdateData.Pose);
			}
		}
	}
	public class EntityUnqueueRequestData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 3;

		public byte userId;

		public ushort queuedId;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref userId);
			serializer.SerializeValue(ref queuedId);
		}

		public static EntityUnqueueRequestData Create(byte userId, ushort queuedId)
		{
			return new EntityUnqueueRequestData
			{
				userId = userId,
				queuedId = queuedId
			};
		}
	}
	public class EntityUnqueueRequestMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.EntityUnqueueRequest;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ServerOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			EntityUnqueueRequestData entityUnqueueRequestData = received.ReadData<EntityUnqueueRequestData>();
			ushort allocatedId = NetworkEntityManager.IDManager.RegisteredEntities.AllocateNewID();
			MessageRelay.RelayNative(EntityUnqueueResponseData.Create(entityUnqueueRequestData.queuedId, allocatedId), NativeMessageTag.EntityUnqueueResponse, new MessageRoute(entityUnqueueRequestData.userId, NetworkChannel.Reliable));
		}
	}
	public class EntityUnqueueResponseData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 4;

		public ushort queuedId;

		public ushort allocatedId;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref queuedId);
			serializer.SerializeValue(ref allocatedId);
		}

		public static EntityUnqueueResponseData Create(ushort queuedId, ushort allocatedId)
		{
			return new EntityUnqueueResponseData
			{
				queuedId = queuedId,
				allocatedId = allocatedId
			};
		}
	}
	public class EntityUnqueueResponseMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.EntityUnqueueResponse;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ClientsOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			EntityUnqueueResponseData entityUnqueueResponseData = received.ReadData<EntityUnqueueResponseData>();
			NetworkEntityManager.IDManager.UnqueueEntity(entityUnqueueResponseData.queuedId, entityUnqueueResponseData.allocatedId);
		}
	}
	public class EntityZoneRegisterMessage : NativeMessageHandler
	{
		[CompilerGenerated]
		private sealed class <RepeatCull>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MarrowEntity entity;

			private int <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RepeatCull>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < 3)
				{
					SafeZoneCuller.Cull(entity, isInactive: false);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public override byte Tag => NativeMessageTag.EntityZoneRegister;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			if (received.ReadData<NetworkEntityReference>().TryGetEntity(out var entity) && received.Sender == entity.OwnerID.SmallID)
			{
				IMarrowEntityExtender extender = entity.GetExtender<IMarrowEntityExtender>();
				if (extender != null && !((Object)(object)extender.MarrowEntity == (Object)null))
				{
					MelonCoroutines.Start(RepeatCull(extender.MarrowEntity));
				}
			}
		}

		[IteratorStateMachine(typeof(<RepeatCull>d__3))]
		private static IEnumerator RepeatCull(MarrowEntity entity)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RepeatCull>d__3(0)
			{
				entity = entity
			};
		}
	}
	public class NetworkPropCreateData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 11;

		public byte OwnerID;

		public ComponentHashData HashData;

		public ushort EntityID;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref OwnerID);
			NetSerializerExtensions.SerializeValue(serializer, ref HashData);
			serializer.SerializeValue(ref EntityID);
		}

		public static NetworkPropCreateData Create(byte ownerID, ComponentHashData hashData, ushort entityID)
		{
			return new NetworkPropCreateData
			{
				OwnerID = ownerID,
				HashData = hashData,
				EntityID = entityID
			};
		}
	}
	[Net.DelayWhileTargetLoading]
	public class NetworkPropCreateMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.NetworkPropCreate;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			NetworkPropCreateData networkPropCreateData = received.ReadData<NetworkPropCreateData>();
			MarrowEntity entityFromData = MarrowEntityHelper.GetEntityFromData(networkPropCreateData.HashData);
			if (!((Object)(object)entityFromData == (Object)null) && !IMarrowEntityExtender.Cache.ContainsSource(entityFromData))
			{
				NetworkEntity networkEntity = new NetworkEntity
				{
					Source = EntitySource.Scene
				};
				NetworkProp networkProp = new NetworkProp(networkEntity, entityFromData);
				NetworkEntityManager.IDManager.RegisterEntity(networkPropCreateData.EntityID, networkEntity);
				PlayerID playerID = PlayerIDManager.GetPlayerID(networkPropCreateData.OwnerID);
				networkEntity.SetOwner(playerID);
				networkEntity.OnEntityCreationCatchup += delegate(NetworkEntity entity, PlayerID player)
				{
					PropSender.SendCatchupCreation(networkProp, player);
				};
				CatchupManager.RequestEntityDataCatchup(new NetworkEntityReference(networkEntity));
			}
		}
	}
	public enum ExpectedReceiverType
	{
		Both,
		ServerOnly,
		ClientsOnly
	}
	public class GamemodeMetadataRemoveData : LabFusion.Network.Serialization.INetSerializable
	{
		public string GamemodeBarcode;

		public string Key;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref GamemodeBarcode);
			serializer.SerializeValue(ref Key);
		}
	}
	public class GamemodeMetadataRemoveMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.GamemodeMetadataRemove;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ClientsOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			GamemodeMetadataRemoveData gamemodeMetadataRemoveData = received.ReadData<GamemodeMetadataRemoveData>();
			if (GamemodeManager.TryGetGamemode(gamemodeMetadataRemoveData.GamemodeBarcode, out var gamemode))
			{
				gamemode.Metadata.ForceRemoveLocalMetadata(gamemodeMetadataRemoveData.Key);
			}
		}
	}
	public class GamemodeMetadataSetData : LabFusion.Network.Serialization.INetSerializable
	{
		public string GamemodeBarcode;

		public string Key;

		public string Value;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref GamemodeBarcode);
			serializer.SerializeValue(ref Key);
			serializer.SerializeValue(ref Value);
		}

		public static GamemodeMetadataSetData Create(string gamemodeBarcode, string key, string value)
		{
			return new GamemodeMetadataSetData
			{
				GamemodeBarcode = gamemodeBarcode,
				Key = key,
				Value = value
			};
		}
	}
	public class GamemodeMetadataSetMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.GamemodeMetadataSet;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ClientsOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			GamemodeMetadataSetData gamemodeMetadataSetData = received.ReadData<GamemodeMetadataSetData>();
			if (GamemodeManager.TryGetGamemode(gamemodeMetadataSetData.GamemodeBarcode, out var gamemode))
			{
				gamemode.Metadata.ForceSetLocalMetadata(gamemodeMetadataSetData.Key, gamemodeMetadataSetData.Value);
			}
		}
	}
	public class GamemodeTriggerResponseData : LabFusion.Network.Serialization.INetSerializable
	{
		public string GamemodeBarcode;

		public string TriggerName;

		public string TriggerValue;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref GamemodeBarcode);
			serializer.SerializeValue(ref TriggerName);
			serializer.SerializeValue(ref TriggerValue);
		}
	}
	public class GamemodeTriggerResponseMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.GamemodeTriggerResponse;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			GamemodeTriggerResponseData gamemodeTriggerResponseData = received.ReadData<GamemodeTriggerResponseData>();
			if (GamemodeManager.TryGetGamemode(gamemodeTriggerResponseData.GamemodeBarcode, out var gamemode))
			{
				if (!string.IsNullOrWhiteSpace(gamemodeTriggerResponseData.TriggerValue))
				{
					gamemode.Relay.ForceInvokeLocalTrigger(gamemodeTriggerResponseData.TriggerName, gamemodeTriggerResponseData.TriggerValue);
				}
				else
				{
					gamemode.Relay.ForceInvokeLocalTrigger(gamemodeTriggerResponseData.TriggerName);
				}
			}
		}
	}
	public class SlowMoButtonMessageData : LabFusion.Network.Serialization.INetSerializable
	{
		public bool Decrease;

		public int? GetSize()
		{
			return 1;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Decrease);
		}
	}
	[Net.SkipHandleWhileLoading]
	public class SlowMoButtonMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.SlowMoButton;

		protected override bool OnPreRelayMessage(ReceivedMessage received)
		{
			return CommonPreferences.SlowMoMode switch
			{
				TimeScaleMode.DISABLED => false, 
				TimeScaleMode.LOW_GRAVITY => false, 
				TimeScaleMode.CLIENT_SIDE => false, 
				TimeScaleMode.HOST_ONLY => received.Sender == 0, 
				_ => true, 
			};
		}

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			SlowMoButtonMessageData slowMoButtonMessageData = received.ReadData<SlowMoButtonMessageData>();
			TimeManagerPatches.IgnorePatches = true;
			if (slowMoButtonMessageData.Decrease)
			{
				TimeManager.DECREASE_TIMESCALE();
			}
			else
			{
				TimeManager.TOGGLE_TIMESCALE();
			}
			TimeManagerPatches.IgnorePatches = false;
		}
	}
	public class PlayerRepGrabData : LabFusion.Network.Serialization.INetSerializable
	{
		public Handedness Handedness;

		public GrabGroup Group;

		public SerializedGrab SerializedGrab;

		public int? GetSize()
		{
			return 2 + SerializedGrab.GetSize();
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue<Handedness>(ref Handedness, Precision.OneByte);
			serializer.SerializeValue(ref Group, Precision.OneByte);
			GrabGroupHandler.SerializeGrab(ref SerializedGrab, serializer, Group);
		}

		public Grip GetGrip()
		{
			return SerializedGrab.GetGrip();
		}
	}
	[Net.SkipHandleWhileLoading]
	public class PlayerRepGrabMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PlayerRepGrab;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			PlayerRepGrabData data = received.ReadData<PlayerRepGrabData>();
			byte? sender = received.Sender;
			if (sender.HasValue)
			{
				ApplyGrip(sender.Value, data);
			}
		}

		private static void ApplyGrip(byte sender, PlayerRepGrabData data)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkPlayerManager.TryGetPlayer(sender, out var player))
			{
				Grip grip = data.GetGrip();
				if (!((Object)(object)grip == (Object)null))
				{
					data.SerializedGrab.RequestGrab(player, data.Handedness, grip);
				}
			}
		}
	}
	public class PlayerRepReleaseData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 1;

		public Handedness Handedness;

		public int? GetSize()
		{
			return 1;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue<Handedness>(ref Handedness, Precision.OneByte);
		}
	}
	[Net.SkipHandleWhileLoading]
	public class PlayerRepReleaseMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PlayerRepRelease;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			PlayerRepReleaseData playerRepReleaseData = received.ReadData<PlayerRepReleaseData>();
			byte? sender = received.Sender;
			if (sender.HasValue && NetworkPlayerManager.TryGetPlayer(sender.Value, out var player) && player.HasRig)
			{
				player.Grabber.Detach(playerRepReleaseData.Handedness);
			}
		}
	}
	public class PlayerRepSeatData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 4;

		public ushort SeatID;

		public byte SeatIndex;

		public bool IsIngress;

		public int? GetSize()
		{
			return 4;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref SeatID);
			serializer.SerializeValue(ref SeatIndex);
			serializer.SerializeValue(ref IsIngress);
		}
	}
	[Net.SkipHandleWhileLoading]
	public class PlayerRepSeatMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PlayerRepSeat;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			PlayerRepSeatData data = received.ReadData<PlayerRepSeatData>();
			byte? sender = received.Sender;
			NetworkEntity seatEntity;
			if (sender.HasValue && NetworkPlayerManager.TryGetPlayer(sender.Value, out var player))
			{
				seatEntity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(data.SeatID);
				if (seatEntity != null)
				{
					player.HookOnReady(OnPlayerReady);
				}
			}
			void OnPlayerReady()
			{
				SeatExtender extender = seatEntity.GetExtender<SeatExtender>();
				if (extender != null)
				{
					Seat component = extender.GetComponent(data.SeatIndex);
					if (!((Object)(object)component == (Object)null))
					{
						SeatPatches.IgnorePatches = true;
						if (data.IsIngress)
						{
							component.IngressRig(player.RigRefs.RigManager);
						}
						else if (Object.op_Implicit((Object)(object)player.RigRefs.RigManager.activeSeat))
						{
							player.RigRefs.RigManager.activeSeat.EgressRig(true);
						}
					}
				}
			}
		}
	}
	public class LevelLoadData : LabFusion.Network.Serialization.INetSerializable
	{
		public string LevelBarcode;

		public string LoadingScreenBarcode;

		public int? GetSize()
		{
			return LevelBarcode.GetSize() + LoadingScreenBarcode.GetSize();
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref LevelBarcode);
			serializer.SerializeValue(ref LoadingScreenBarcode);
		}

		public static LevelLoadData Create(string levelBarcode, string loadBarcode)
		{
			return new LevelLoadData
			{
				LevelBarcode = levelBarcode,
				LoadingScreenBarcode = loadBarcode
			};
		}
	}
	public class LevelLoadMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.SceneLoad;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ClientsOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			LevelLoadData levelLoadData = received.ReadData<LevelLoadData>();
			FusionSceneManager.SetTargetScene(levelLoadData.LevelBarcode, levelLoadData.LoadingScreenBarcode);
		}
	}
	public class LevelRequestData : LabFusion.Network.Serialization.INetSerializable
	{
		public string Barcode;

		public string Title;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Barcode);
			serializer.SerializeValue(ref Title);
		}
	}
	public class LevelRequestMessage : NativeMessageHandler
	{
		private const float _requestCooldown = 10f;

		private static float _timeOfRequest = -1000f;

		public override byte Tag => NativeMessageTag.LevelRequest;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ServerOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			if (TimeReferences.TimeSinceStartup - _timeOfRequest <= 10f)
			{
				return;
			}
			byte? sender = received.Sender;
			if (!sender.HasValue)
			{
				return;
			}
			_timeOfRequest = TimeReferences.TimeSinceStartup;
			LevelRequestData data = received.ReadData<LevelRequestData>();
			PlayerID playerID = PlayerIDManager.GetPlayerID(sender.Value);
			if (playerID != null && playerID.TryGetDisplayName(out var name))
			{
				Notifier.Send(new Notification
				{
					Title = data.Title + " Load Request",
					Message = new NotificationText(name + " has requested to load " + data.Title + ".", Color.yellow),
					SaveToMenu = true,
					ShowPopup = true,
					OnAccepted = delegate
					{
						//IL_000b: Unknown result type (might be due to invalid IL or missing references)
						//IL_0016: Expected O, but got Unknown
						SceneStreamer.Load(new Barcode(data.Barcode), (Barcode)null);
					}
				});
			}
		}
	}
	public abstract class MessageHandler
	{
		public virtual ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.Both;

		public Net.NetAttribute[] NetAttributes { get; set; }

		internal virtual void StartHandlingMessage(ReceivedMessage received)
		{
			if (NetAttributes.Length == 0)
			{
				FinishHandlingMessage(received);
				return;
			}
			for (int i = 0; i < NetAttributes.Length; i++)
			{
				NetAttributes[i].OnHandleBegin();
			}
			for (int j = 0; j < NetAttributes.Length; j++)
			{
				if (NetAttributes[j].StopHandling())
				{
					return;
				}
			}
			Net.NetAttribute netAttribute = null;
			for (int k = 0; k < NetAttributes.Length; k++)
			{
				Net.NetAttribute netAttribute2 = NetAttributes[k];
				if (netAttribute2.IsAwaitable())
				{
					netAttribute = netAttribute2;
					break;
				}
			}
			if (netAttribute != null)
			{
				netAttribute.HookComplete(delegate
				{
					FinishHandlingMessage(received);
				});
			}
			else
			{
				FinishHandlingMessage(received);
			}
		}

		internal virtual void FinishHandlingMessage(ReceivedMessage received)
		{
			try
			{
				Handle(received);
			}
			catch (Exception e)
			{
				FusionLogger.LogException("handling message of type " + GetType().Name, e);
			}
		}

		internal bool ProcessPreRelayMessage(ReceivedMessage received)
		{
			return OnPreRelayMessage(received);
		}

		public void CheckExpectedConditions(ReceivedMessage received)
		{
			bool isServerHandled = received.IsServerHandled;
			if (ExpectedReceiver == ExpectedReceiverType.ServerOnly && !isServerHandled)
			{
				throw new MessageExpectedServerException();
			}
			if (ExpectedReceiver == ExpectedReceiverType.ClientsOnly && isServerHandled)
			{
				throw new MessageExpectedClientException();
			}
		}

		public abstract void Handle(ReceivedMessage received);

		protected virtual bool OnPreRelayMessage(ReceivedMessage received)
		{
			return true;
		}

		protected virtual void OnHandleMessage(ReceivedMessage received)
		{
		}
	}
	public class MessagePrefix : LabFusion.Network.Serialization.INetSerializable
	{
		public byte Tag;

		public MessageRoute Route;

		public byte? Sender;

		public int? GetSize()
		{
			return 3 + Route.GetSize();
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Tag);
			NetSerializerExtensions.SerializeValue(serializer, ref Route);
			if (Route.Type != 0)
			{
				serializer.SerializeValue(ref Sender);
			}
		}
	}
	public struct MessageRoute : LabFusion.Network.Serialization.INetSerializable
	{
		public RelayType Type { get; set; }

		public NetworkChannel Channel { get; set; }

		public byte? Target { get; set; }

		public ArraySegment<byte> Targets { get; set; }

		public MessageRoute(RelayType type, NetworkChannel channel)
		{
			Type = type;
			Channel = channel;
			Target = null;
			Targets = ArraySegment<byte>.Empty;
		}

		public MessageRoute(byte target, NetworkChannel channel)
		{
			Type = RelayType.ToTarget;
			Channel = channel;
			Target = target;
			Targets = ArraySegment<byte>.Empty;
		}

		public MessageRoute(ArraySegment<byte> targets, NetworkChannel channel)
		{
			Type = RelayType.ToTargets;
			Channel = channel;
			Target = null;
			Targets = targets;
		}

		public MessageRoute(NetworkChannel channel, params byte[] targets)
			: this(new ArraySegment<byte>(targets), channel)
		{
		}

		public readonly int GetSize()
		{
			int num = 2;
			if (Type == RelayType.ToTarget)
			{
				num += 2;
			}
			if (Type == RelayType.ToTargets)
			{
				num += 4 + Targets.Count;
			}
			return num;
		}

		public void Serialize(INetSerializer serializer)
		{
			RelayType value = Type;
			NetworkChannel value2 = Channel;
			byte? value3 = Target;
			ArraySegment<byte> value4 = Targets;
			serializer.SerializeValue(ref value, Precision.OneByte);
			serializer.SerializeValue(ref value2, Precision.OneByte);
			if (value == RelayType.ToTarget)
			{
				serializer.SerializeValue(ref value3);
			}
			if (value == RelayType.ToTargets)
			{
				serializer.SerializeValue(ref value4);
			}
			if (serializer.IsReader)
			{
				Type = value;
				Channel = value2;
				Target = value3;
				Targets = value4;
			}
		}
	}
	public abstract class NativeMessageHandler : MessageHandler
	{
		public static readonly NativeMessageHandler[] Handlers = new NativeMessageHandler[255];

		public abstract byte Tag { get; }

		public static void RegisterHandlersFromAssembly(Assembly targetAssembly)
		{
			if (targetAssembly == null)
			{
				throw new NullReferenceException("Can't register from a null assembly!");
			}
			AssemblyUtilities.LoadAllValid<NativeMessageHandler>(targetAssembly, RegisterHandler);
		}

		public static void RegisterHandler<T>() where T : NativeMessageHandler
		{
			RegisterHandler(typeof(T));
		}

		protected static void RegisterHandler(Type type)
		{
			NativeMessageHandler nativeMessageHandler = Activator.CreateInstance(type) as NativeMessageHandler;
			nativeMessageHandler.NetAttributes = type.GetCustomAttributes<Net.NetAttribute>().ToArray();
			byte tag = nativeMessageHandler.Tag;
			if (Handlers[tag] != null)
			{
				throw new Exception(type.Name + " has the same index as " + Handlers[tag].GetType().Name + ", we can't replace handlers!");
			}
			Handlers[tag] = nativeMessageHandler;
		}

		public static void ReadMessage(ReadableMessage message)
		{
			bool isServerHandled = message.IsServerHandled;
			int length = message.Buffer.Length;
			NetworkInfo.BytesDown += length;
			byte b = 0;
			try
			{
				using NetReader netReader = NetReader.Create(message.Buffer.ToArray());
				MessagePrefix value = null;
				NetSerializerExtensions.SerializeValue(netReader, ref value);
				MessageRoute route = value.Route;
				byte? sender = value.Sender;
				ulong? platformID = message.PlatformID;
				if (isServerHandled && !ValidateReceivedID(route.Type, ref sender, ref platformID))
				{
					NetworkConnectionManager.DisconnectUser(platformID.Value);
					return;
				}
				byte[] bytes = netReader.ReadBytes();
				b = value.Tag;
				if (Handlers[b] != null)
				{
					ReceivedMessage receivedMessage = default(ReceivedMessage);
					receivedMessage.Route = route;
					receivedMessage.Sender = sender;
					receivedMessage.PlatformID = platformID;
					receivedMessage.Bytes = bytes;
					receivedMessage.IsServerHandled = message.IsServerHandled;
					ReceivedMessage received = receivedMessage;
					Handlers[b].StartHandlingMessage(received);
				}
			}
			catch (Exception ex)
			{
				FusionLogger.Error($"Failed handling network message of tag {b} with reason: {ex.Message}\nTrace:{ex.StackTrace}");
			}
		}

		private static bool ValidateReceivedID(RelayType relayType, ref byte? sender, ref ulong? platformID)
		{
			if (!platformID.HasValue)
			{
				return true;
			}
			PlayerID playerID = PlayerIDManager.GetPlayerID(platformID.Value);
			if (playerID == null)
			{
				if (relayType != 0)
				{
					return false;
				}
				if (sender.HasValue && PlayerIDManager.HasPlayerID(sender.Value))
				{
					return false;
				}
				sender = null;
				return true;
			}
			byte smallID = playerID.SmallID;
			if (!sender.HasValue)
			{
				sender = smallID;
				return true;
			}
			if (smallID != sender.Value)
			{
				return false;
			}
			return true;
		}

		public sealed override void Handle(ReceivedMessage received)
		{
			CheckExpectedConditions(received);
			if (received.IsServerHandled && !OnPreRelayMessage(received))
			{
				return;
			}
			MessageRoute route = received.Route;
			RelayType type = route.Type;
			NetworkChannel channel = route.Channel;
			switch (type)
			{
			case RelayType.ToServer:
				if (!received.IsServerHandled)
				{
					throw new MessageExpectedServerException();
				}
				break;
			case RelayType.ToClients:
				if (received.IsServerHandled)
				{
					using (NetMessage message3 = NetMessage.Create(Tag, received))
					{
						MessageSender.BroadcastMessage(channel, message3);
						return;
					}
				}
				break;
			case RelayType.ToOtherClients:
				if (received.IsServerHandled)
				{
					using (NetMessage message4 = NetMessage.Create(Tag, received))
					{
						MessageSender.BroadcastMessageExcept(received.Sender.Value, channel, message4, ignoreHost: false);
						return;
					}
				}
				break;
			case RelayType.ToTarget:
				if (received.IsServerHandled)
				{
					using (NetMessage message2 = NetMessage.Create(Tag, received))
					{
						MessageSender.SendFromServer(route.Target.Value, channel, message2);
						return;
					}
				}
				break;
			case RelayType.ToTargets:
			{
				if (!received.IsServerHandled)
				{
					break;
				}
				using NetMessage message = NetMessage.Create(Tag, received);
				foreach (byte target in route.Targets)
				{
					MessageSender.SendFromServer(target, channel, message);
				}
				return;
			}
			}
			OnHandleMessage(received);
		}
	}
	public static class NativeMessageTag
	{
		public static readonly byte Unknown = 0;

		public static readonly byte ConnectionRequest = 1;

		public static readonly byte ConnectionResponse = 2;

		public static readonly byte Disconnect = 3;

		public static readonly byte PlayerPoseUpdate = 4;

		public static readonly byte PlayerRepAvatar = 5;

		public static readonly byte PhysicsRigState = 7;

		public static readonly byte PlayerRepSeat = 8;

		public static readonly byte PlayerRepGrab = 9;

		public static readonly byte PlayerRepRelease = 10;

		public static readonly byte PlayerRepAnchors = 11;

		public static readonly byte SceneLoad = 12;

		public static readonly byte EntityUnqueueRequest = 13;

		public static readonly byte EntityUnqueueResponse = 14;

		public static readonly byte EntityOwnershipRequest = 15;

		public static readonly byte EntityOwnershipResponse = 16;

		public static readonly byte EntityPoseUpdate = 17;

		public static readonly byte NetworkPropCreate = 18;

		public static readonly byte EntityZoneRegister = 19;

		public static readonly byte SpawnRequest = 20;

		public static readonly byte SpawnResponse = 21;

		public static readonly byte DespawnRequest = 22;

		public static readonly byte DespawnResponse = 23;

		public static readonly byte PlayerSettings = 44;

		public static readonly byte ServerSettings = 45;

		public static readonly byte PlayerRepAction = 50;

		public static readonly byte SlowMoButton = 58;

		public static readonly byte PlayerMetadataRequest = 59;

		public static readonly byte PlayerMetadataResponse = 60;

		public static readonly byte LevelRequest = 62;

		public static readonly byte PlayerRepDamage = 64;

		public static readonly byte PlayerVoiceChat = 67;

		public static readonly byte PermissionCommandRequest = 68;

		public static readonly byte PlayerRepTeleport = 69;

		public static readonly byte ModInfoRequest = 77;

		public static readonly byte ModInfoResponse = 78;

		public static readonly byte EntityDataRequest = 79;

		public static readonly byte EntityCullStatus = 80;

		public static readonly byte Module = 200;

		public static readonly byte DynamicsAssignment = 201;

		public static readonly byte GamemodeMetadataSet = 202;

		public static readonly byte GamemodeMetadataRemove = 203;

		public static readonly byte GamemodeTriggerResponse = 204;

		public static readonly byte PointItemEquipState = 206;

		public static readonly byte PointItemTrigger = 207;

		public static readonly byte PointItemTriggerValue = 208;

		public static readonly byte RPCEvent = 209;

		public static readonly byte RPCInt = 210;

		public static readonly byte RPCFloat = 211;

		public static readonly byte RPCBool = 212;

		public static readonly byte RPCString = 213;

		public static readonly byte RPCVector3 = 214;

		public static readonly byte RPCMethod = 215;
	}
	public class NetMessage : IDisposable
	{
		private unsafe byte* _buffer;

		private int _size;

		private bool _disposed;

		public int Length => _size;

		public unsafe byte* Buffer => _buffer;

		private unsafe static NetMessage Create(int size)
		{
			return new NetMessage
			{
				_buffer = (byte*)(void*)Marshal.AllocHGlobal(size),
				_size = size,
				_disposed = false
			};
		}

		public static NetMessage Create(byte tag, NetWriter writer, MessageRoute route, byte? sender = null)
		{
			return Create(tag, writer.Buffer, route, sender);
		}

		public unsafe static NetMessage Create(byte tag, ArraySegment<byte> buffer, MessageRoute route, byte? sender = null)
		{
			MessagePrefix value = new MessagePrefix
			{
				Tag = tag,
				Route = route,
				Sender = sender
			};
			using NetWriter netWriter = NetWriter.Create(value.GetSize().Value + buffer.Count + 4);
			NetSerializerExtensions.SerializeValue(netWriter, ref value);
			netWriter.Write(buffer);
			int length = netWriter.Length;
			NetMessage netMessage = Create(length);
			for (int i = 0; i < length; i++)
			{
				netMessage._buffer[i] = netWriter.Buffer[i];
			}
			return netMessage;
		}

		public unsafe static NetMessage Create(byte tag, ReceivedMessage received)
		{
			MessagePrefix value = new MessagePrefix
			{
				Tag = tag,
				Route = received.Route,
				Sender = received.Sender
			};
			using NetWriter netWriter = NetWriter.Create(value.GetSize().Value + received.Bytes.Length + 4);
			NetSerializerExtensions.SerializeValue(netWriter, ref value);
			netWriter.Write(received.Bytes);
			int length = netWriter.Length;
			NetMessage netMessage = Create(length);
			for (int i = 0; i < length; i++)
			{
				netMessage._buffer[i] = netWriter.Buffer[i];
			}
			return netMessage;
		}

		public static NetMessage ModuleCreate<TMessage>(NetWriter writer, MessageRoute route, byte? sender = null) where TMessage : ModuleMessageHandler
		{
			return ModuleCreate(typeof(TMessage), writer, route, sender);
		}

		public static NetMessage ModuleCreate<TMessage>(byte[] buffer, MessageRoute route, byte? sender = null) where TMessage : ModuleMessageHandler
		{
			return ModuleCreate(typeof(TMessage), buffer, route, sender);
		}

		public static NetMessage ModuleCreate(Type type, NetWriter writer, MessageRoute route, byte? sender = null)
		{
			return ModuleCreate(type, writer.Buffer, route, sender);
		}

		public unsafe static NetMessage ModuleCreate(Type type, ArraySegment<byte> buffer, MessageRoute route, byte? sender = null)
		{
			long? handlerTagByType = ModuleMessageManager.GetHandlerTagByType(type);
			if (!handlerTagByType.HasValue)
			{
				return null;
			}
			long value = handlerTagByType.Value;
			MessagePrefix value2 = new MessagePrefix
			{
				Tag = NativeMessageTag.Module,
				Route = route,
				Sender = sender
			};
			using NetWriter netWriter = NetWriter.Create(value2.GetSize().Value + buffer.Count + 8 + 4);
			NetSerializerExtensions.SerializeValue(netWriter, ref value2);
			byte[] array = new byte[buffer.Count + 8];
			BinaryPrimitives.WriteInt64BigEndian(array, value);
			for (int i = 0; i < buffer.Count; i++)
			{
				array[i + 8] = buffer[i];
			}
			netWriter.Write(array);
			int length = netWriter.Length;
			NetMessage netMessage = Create(length);
			for (int j = 0; j < length; j++)
			{
				netMessage._buffer[j] = netWriter.Buffer[j];
			}
			return netMessage;
		}

		public unsafe byte[] ToByteArray()
		{
			byte[] array = new byte[Length];
			Marshal.Copy((IntPtr)_buffer, array, 0, Length);
			return array;
		}

		public unsafe void Dispose()
		{
			if (!_disposed)
			{
				GC.SuppressFinalize(this);
				Marshal.FreeHGlobal((IntPtr)_buffer);
				_disposed = true;
			}
		}
	}
	public enum NetworkChannel : byte
	{
		Reliable,
		Unreliable
	}
	public class PointItemEquipStateData : LabFusion.Network.Serialization.INetSerializable
	{
		public string Barcode;

		public bool IsEquipped;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Barcode);
			serializer.SerializeValue(ref IsEquipped);
		}
	}
	public class PointItemEquipStateMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PointItemEquipState;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			PointItemEquipStateData pointItemEquipStateData = received.ReadData<PointItemEquipStateData>();
			byte? sender = received.Sender;
			if (sender.HasValue && PointItemManager.TryGetPointItem(pointItemEquipStateData.Barcode, out var _))
			{
				PlayerIDManager.GetPlayerID(sender.Value).ForceSetEquipped(pointItemEquipStateData.Barcode, pointItemEquipStateData.IsEquipped);
			}
		}
	}
	public class PointItemTriggerData : LabFusion.Network.Serialization.INetSerializable
	{
		public string Barcode;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Barcode);
		}
	}
	public class PointItemTriggerMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PointItemTrigger;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			PointItemTriggerData pointItemTriggerData = received.ReadData<PointItemTriggerData>();
			byte? sender = received.Sender;
			if (sender.HasValue)
			{
				PointItemManager.Internal_OnTriggerItem(PlayerIDManager.GetPlayerID(sender.Value), pointItemTriggerData.Barcode);
			}
		}
	}
	public class PointItemTriggerValueData : LabFusion.Network.Serialization.INetSerializable
	{
		public string Barcode;

		public string Value;

		public int? GetSize()
		{
			return Barcode.GetSize() + Value.GetSize();
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Barcode);
			serializer.SerializeValue(ref Value);
		}
	}
	public class PointItemTriggerValueMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PointItemTriggerValue;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			PointItemTriggerValueData pointItemTriggerValueData = received.ReadData<PointItemTriggerValueData>();
			byte? sender = received.Sender;
			if (sender.HasValue)
			{
				PointItemManager.Internal_OnTriggerItem(PlayerIDManager.GetPlayerID(sender.Value), pointItemTriggerValueData.Barcode, pointItemTriggerValueData.Value);
			}
		}
	}
	public ref struct ReadableMessage
	{
		public ReadOnlySpan<byte> Buffer { get; set; }

		public bool IsServerHandled { get; set; }

		public ulong? PlatformID { get; set; }
	}
	public struct ReceivedMessage
	{
		public MessageRoute Route { get; set; }

		public byte? Sender { get; set; }

		public ulong? PlatformID { get; set; }

		public byte[] Bytes { get; set; }

		public bool IsServerHandled { get; set; }

		public readonly TSerializable ReadData<TSerializable>() where TSerializable : LabFusion.Network.Serialization.INetSerializable, new()
		{
			using NetReader serializer = NetReader.Create(Bytes);
			TSerializable value = default(TSerializable);
			NetSerializerExtensions.SerializeValue(serializer, ref value);
			return value;
		}
	}
	public enum RelayType : byte
	{
		None,
		ToServer,
		ToClients,
		ToOtherClients,
		ToTarget,
		ToTargets
	}
	public enum PhysicsRigStateType
	{
		SHUTDOWN,
		RAGDOLL,
		LEG_SHUTDOWN,
		PHYSICAL_LEGS
	}
	public class PhysicsRigStateData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 4;

		public PhysicsRigStateType Type;

		public bool Enabled;

		public bool Left;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Type, Precision.OneByte);
			serializer.SerializeValue(ref Enabled);
			serializer.SerializeValue(ref Left);
		}

		public void Apply(PhysicsRig physicsRig)
		{
			switch (Type)
			{
			case PhysicsRigStateType.SHUTDOWN:
				if (Enabled)
				{
					physicsRig.ShutdownRig();
				}
				else
				{
					physicsRig.TurnOnRig();
				}
				break;
			case PhysicsRigStateType.RAGDOLL:
				if (Enabled)
				{
					physicsRig.RagdollRig();
				}
				else
				{
					physicsRig.UnRagdollRig();
				}
				break;
			case PhysicsRigStateType.LEG_SHUTDOWN:
			{
				PhysLimb val = (Left ? physicsRig.legLf : physicsRig.legRt);
				if (Enabled)
				{
					val.ShutdownLimb();
				}
				break;
			}
			case PhysicsRigStateType.PHYSICAL_LEGS:
				if (Enabled)
				{
					physicsRig.PhysicalLegs();
				}
				else
				{
					physicsRig.KinematicLegs();
				}
				break;
			}
		}

		public static PhysicsRigStateData Create(PhysicsRigStateType type, bool enabled, bool left = false)
		{
			return new PhysicsRigStateData
			{
				Type = type,
				Enabled = enabled,
				Left = left
			};
		}
	}
	[Net.SkipHandleWhileLoading]
	public class PhysicsRigStateMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PhysicsRigState;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			byte? sender = received.Sender;
			if (sender.HasValue)
			{
				PhysicsRigStateData data = received.ReadData<PhysicsRigStateData>();
				if (NetworkPlayerManager.TryGetPlayer(sender.Value, out var player))
				{
					player.EnqueuePhysicsRigState(data);
				}
			}
		}
	}
	public class PlayerPoseUpdateData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 122;

		public RigPose Pose;

		public int? GetSize()
		{
			return 122;
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref Pose);
		}

		public static PlayerPoseUpdateData Create(RigPose pose)
		{
			return new PlayerPoseUpdateData
			{
				Pose = pose
			};
		}
	}
	[Net.SkipHandleWhileLoading]
	public class PlayerPoseUpdateMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PlayerPoseUpdate;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			PlayerPoseUpdateData playerPoseUpdateData = received.ReadData<PlayerPoseUpdateData>();
			byte value = received.Sender.Value;
			if (value == PlayerIDManager.LocalSmallID)
			{
				throw new Exception("Player received a pose for their own player.");
			}
			NetworkEntity entity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(value);
			if (entity == null)
			{
				FusionLogger.Error($"PlayerPoseUpdateMessage could not find an entity with id {value}!");
			}
			else
			{
				NetworkPlayer extender = entity.GetExtender<NetworkPlayer>();
				if (extender == null)
				{
					FusionLogger.Error("PlayerPoseUpdateMessage could not get a NetworkPlayer from the player entity!");
				}
				else
				{
					extender.OnReceivePose(playerPoseUpdateData.Pose);
				}
			}
		}
	}
	public class PlayerRepActionData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 2;

		public PlayerActionType Type;

		public byte? OtherPlayer;

		public int? GetSize()
		{
			return 2;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Type, Precision.OneByte);
			serializer.SerializeValue(ref OtherPlayer);
		}
	}
	public class PlayerRepActionMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PlayerRepAction;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			PlayerRepActionData playerRepActionData = received.ReadData<PlayerRepActionData>();
			byte? sender = received.Sender;
			if (!sender.HasValue || !NetworkPlayerManager.TryGetPlayer(sender.Value, out var player))
			{
				return;
			}
			PlayerID otherPlayer = (playerRepActionData.OtherPlayer.HasValue ? PlayerIDManager.GetPlayerID(playerRepActionData.OtherPlayer.Value) : null);
			if (!player.NetworkEntity.IsOwner && player.HasRig)
			{
				RigManager rigManager = player.RigRefs.RigManager;
				switch (playerRepActionData.Type)
				{
				case PlayerActionType.JUMP:
					rigManager.remapHeptaRig.Jump();
					break;
				case PlayerActionType.DEATH:
					rigManager.physicsRig.headSfx.DeathVocal();
					player.RigRefs.DisableInteraction();
					break;
				case PlayerActionType.DYING:
					rigManager.physicsRig.headSfx.DyingVocal();
					break;
				case PlayerActionType.RECOVERY:
					rigManager.physicsRig.headSfx.RecoveryVocal();
					break;
				case PlayerActionType.RESPAWN:
					rigManager.health.Respawn();
					rigManager.physicsRig.TeleportToPose();
					break;
				}
			}
			MultiplayerHooking.InvokeOnPlayerAction(player.PlayerID, playerRepActionData.Type, otherPlayer);
		}
	}
	public class PlayerRepAvatarData : LabFusion.Network.Serialization.INetSerializable
	{
		public SerializedAvatarStats Stats;

		public string Barcode;

		public int? GetSize()
		{
			return 420 + Barcode.GetSize();
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref Stats);
			serializer.SerializeValue(ref Barcode);
		}
	}
	public class PlayerRepAvatarMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PlayerRepAvatar;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			PlayerRepAvatarData playerRepAvatarData = received.ReadData<PlayerRepAvatarData>();
			byte? sender = received.Sender;
			if (sender.HasValue)
			{
				string text = playerRepAvatarData.Barcode;
				if (ModBlacklist.IsBlacklisted(text) || GlobalModBlacklistManager.IsBarcodeBlacklisted(text))
				{
					text = ((ScannableReference)MarrowGameReferences.CalibrationAvatarReference).Barcode.ID;
				}
				if (NetworkPlayerManager.TryGetPlayer(sender.Value, out var player))
				{
					player.AvatarSetter.SwapAvatar(playerRepAvatarData.Stats, text);
				}
			}
		}
	}
	public class PlayerRepDamageData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 45;

		public SerializedAttack Attack;

		public BodyPart Part;

		public int? GetSize()
		{
			return 45;
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref Attack);
			serializer.SerializeValue<BodyPart>(ref Part, Precision.OneByte);
		}
	}
	[Net.SkipHandleWhileLoading]
	public class PlayerRepDamageMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PlayerRepDamage;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			PlayerRepDamageData playerRepDamageData = received.ReadData<PlayerRepDamageData>();
			byte? sender = received.Sender;
			if (sender.HasValue)
			{
				byte value = sender.Value;
				Health health = RigData.Refs.RigManager.health;
				Attack attack = playerRepDamageData.Attack.Attack;
				FusionPlayer.LastAttacker = value;
				health.OnReceivedDamage(attack, playerRepDamageData.Part);
				LocalHealth.InvokeAttackedByPlayer(attack, playerRepDamageData.Part, PlayerIDManager.GetPlayerID(value));
			}
		}
	}
	public class PlayerRepTeleportData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 12;

		public Vector3 Position;

		public int? GetSize()
		{
			return 12;
		}

		public void Serialize(INetSerializer serializer)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (serializer.IsReader)
			{
				NetSerializerUnityExtensions.SerializeValue(serializer, ref Position);
				Position = NetworkTransformManager.DecodePosition(Position);
			}
			else
			{
				Vector3 value = NetworkTransformManager.EncodePosition(Position);
				NetSerializerUnityExtensions.SerializeValue(serializer, ref value);
			}
		}
	}
	[Net.SkipHandleWhileLoading]
	public class PlayerRepTeleportMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PlayerRepTeleport;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ClientsOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			LocalPlayer.TeleportToPosition(received.ReadData<PlayerRepTeleportData>().Position, Vector3Extensions.forward);
		}
	}
	public class DynamicsAssignData : LabFusion.Network.Serialization.INetSerializable
	{
		public Dictionary<string, Dictionary<string, string>> GamemodeMetadatas;

		public int? GetSize()
		{
			int num = 0;
			num += 4;
			foreach (KeyValuePair<string, Dictionary<string, string>> gamemodeMetadata in GamemodeMetadatas)
			{
				num += gamemodeMetadata.Key.GetSize();
				num += gamemodeMetadata.Value.GetSize();
			}
			return num;
		}

		public void Serialize(INetSerializer serializer)
		{
			if (serializer.IsReader)
			{
				int value = 0;
				serializer.SerializeValue(ref value);
				GamemodeMetadatas = new Dictionary<string, Dictionary<string, string>>(value);
				for (int i = 0; i < value; i++)
				{
					string value2 = null;
					Dictionary<string, string> value3 = null;
					serializer.SerializeValue(ref value2);
					NetSerializerExtensions.SerializeValue(serializer, ref value3);
					GamemodeMetadatas.Add(value2, value3);
				}
				return;
			}
			int value4 = GamemodeMetadatas.Count;
			serializer.SerializeValue(ref value4);
			foreach (KeyValuePair<string, Dictionary<string, string>> gamemodeMetadata in GamemodeMetadatas)
			{
				string value5 = gamemodeMetadata.Key;
				Dictionary<string, string> value6 = gamemodeMetadata.Value;
				serializer.SerializeValue(ref value5);
				NetSerializerExtensions.SerializeValue(serializer, ref value6);
			}
		}

		public static DynamicsAssignData Create()
		{
			return new DynamicsAssignData
			{
				GamemodeMetadatas = GamemodeRegistration.GetExistingMetadata()
			};
		}
	}
	public class DynamicsAssignMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.DynamicsAssignment;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ClientsOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			GamemodeRegistration.PopulateGamemodeMetadatas(received.ReadData<DynamicsAssignData>().GamemodeMetadatas);
		}
	}
	public class ModuleMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.Module;

		protected override bool OnPreRelayMessage(ReceivedMessage received)
		{
			return ModuleMessageManager.PreRelayMessage(received);
		}

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			ModuleMessageManager.ReadMessage(received);
		}
	}
	public static class RPCBoolSender
	{
		public static bool SetValue(RPCBool rpcBool, bool value)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return false;
			}
			if (RPCVariableExtender.Cache.TryGet(rpcBool, out var value2))
			{
				if (rpcBool.RequiresOwnership && !value2.IsOwner)
				{
					return false;
				}
			}
			else if (rpcBool.RequiresOwnership && !NetworkInfo.IsHost)
			{
				return false;
			}
			MessageRelay.RelayNative(RPCBoolData.Create(ComponentPathData.CreateFromComponent<RPCVariable, RPCVariableExtender>((RPCVariable)rpcBool, RPCVariable.HashTable, RPCVariableExtender.Cache), value), NativeMessageTag.RPCBool, CommonMessageRoutes.ReliableToClients);
			return true;
		}

		public static void CatchupValue(RPCBool rpcBool, PlayerID playerID)
		{
			MessageRelay.RelayNative(RPCBoolData.Create(ComponentPathData.CreateFromComponent<RPCVariable, RPCVariableExtender>((RPCVariable)rpcBool, RPCVariable.HashTable, RPCVariableExtender.Cache), rpcBool.GetLatestValue()), NativeMessageTag.RPCBool, new MessageRoute(playerID.SmallID, NetworkChannel.Reliable));
		}
	}
	[Net.SkipHandleWhileLoading]
	public class RPCBoolData : LabFusion.Network.Serialization.INetSerializable
	{
		public ComponentPathData PathData;

		public bool Value;

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref PathData);
			serializer.SerializeValue(ref Value);
		}

		public static RPCBoolData Create(ComponentPathData pathData, bool value)
		{
			return new RPCBoolData
			{
				PathData = pathData,
				Value = value
			};
		}
	}
	public class RPCBoolMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.RPCBool;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			RPCBoolData rPCBoolData = received.ReadData<RPCBoolData>();
			if (rPCBoolData.PathData.TryGetComponent<RPCVariable, RPCVariableExtender>(RPCVariable.HashTable, out RPCVariable component))
			{
				RPCBool rPCBool = ((Il2CppObjectBase)component).TryCast<RPCBool>();
				if (!((Object)(object)rPCBool == (Object)null))
				{
					OnFoundRPCBool(rPCBool, rPCBoolData.Value);
				}
			}
		}

		private static void OnFoundRPCBool(RPCBool rpcBool, bool value)
		{
			rpcBool.ReceiveValue(value);
		}
	}
	public static class RPCEventSender
	{
		private static RelayType ConvertRPCRelayType(RPCEvent.RPCRelayType relayType)
		{
			return relayType switch
			{
				RPCEvent.RPCRelayType.ToClients => RelayType.ToClients, 
				RPCEvent.RPCRelayType.ToOtherClients => RelayType.ToOtherClients, 
				_ => RelayType.ToServer, 
			};
		}

		private static NetworkChannel ConvertRPCChannel(RPCEvent.RPCChannel channel)
		{
			if (channel == RPCEvent.RPCChannel.Reliable)
			{
				return NetworkChannel.Reliable;
			}
			return NetworkChannel.Unreliable;
		}

		public static bool Invoke(RPCEvent rpcEvent)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return false;
			}
			RelayType type = ConvertRPCRelayType(rpcEvent.RelayType);
			NetworkChannel channel = ConvertRPCChannel(rpcEvent.Channel);
			if (RPCEventExtender.Cache.TryGet(rpcEvent, out var value))
			{
				if (rpcEvent.RequiresOwnership && !value.IsOwner)
				{
					return false;
				}
			}
			else if (Il2CppValueField<bool>.op_Implicit(rpcEvent.requiresOwnership) && !NetworkInfo.IsHost)
			{
				return false;
			}
			MessageRelay.RelayNative(ComponentPathData.CreateFromComponent<RPCEvent, RPCEventExtender>(rpcEvent, RPCEvent.HashTable, RPCEventExtender.Cache), NativeMessageTag.RPCEvent, new MessageRoute(type, channel));
			return true;
		}
	}
	[Net.DelayWhileTargetLoading]
	public class RPCEventMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.RPCEvent;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			if (received.ReadData<ComponentPathData>().TryGetComponent<RPCEvent, RPCEventExtender>(RPCEvent.HashTable, out RPCEvent component))
			{
				OnFoundRPCEvent(component);
			}
		}

		private void OnFoundRPCEvent(RPCEvent rpcEvent)
		{
			rpcEvent.Receive();
		}
	}
	public static class RPCFloatSender
	{
		public static bool SetValue(RPCFloat rpcFloat, float value)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return false;
			}
			if (RPCVariableExtender.Cache.TryGet(rpcFloat, out var value2))
			{
				if (rpcFloat.RequiresOwnership && !value2.IsOwner)
				{
					return false;
				}
			}
			else if (rpcFloat.RequiresOwnership && !NetworkInfo.IsHost)
			{
				return false;
			}
			MessageRelay.RelayNative(RPCFloatData.Create(ComponentPathData.CreateFromComponent<RPCVariable, RPCVariableExtender>((RPCVariable)rpcFloat, RPCVariable.HashTable, RPCVariableExtender.Cache), value), NativeMessageTag.RPCFloat, CommonMessageRoutes.ReliableToClients);
			return true;
		}

		public static void CatchupValue(RPCFloat rpcFloat, PlayerID playerID)
		{
			MessageRelay.RelayNative(RPCFloatData.Create(ComponentPathData.CreateFromComponent<RPCVariable, RPCVariableExtender>((RPCVariable)rpcFloat, RPCVariable.HashTable, RPCVariableExtender.Cache), rpcFloat.GetLatestValue()), NativeMessageTag.RPCFloat, new MessageRoute(playerID.SmallID, NetworkChannel.Reliable));
		}
	}
	public class RPCFloatData : LabFusion.Network.Serialization.INetSerializable
	{
		public ComponentPathData PathData;

		public float Value;

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref PathData);
			serializer.SerializeValue(ref Value);
		}

		public static RPCFloatData Create(ComponentPathData pathData, float value)
		{
			return new RPCFloatData
			{
				PathData = pathData,
				Value = value
			};
		}
	}
	[Net.SkipHandleWhileLoading]
	public class RPCFloatMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.RPCFloat;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			RPCFloatData rPCFloatData = received.ReadData<RPCFloatData>();
			if (rPCFloatData.PathData.TryGetComponent<RPCVariable, RPCVariableExtender>(RPCVariable.HashTable, out RPCVariable component))
			{
				RPCFloat rPCFloat = ((Il2CppObjectBase)component).TryCast<RPCFloat>();
				if (!((Object)(object)rPCFloat == (Object)null))
				{
					OnFoundRPCFloat(rPCFloat, rPCFloatData.Value);
				}
			}
		}

		private static void OnFoundRPCFloat(RPCFloat rpcFloat, float value)
		{
			rpcFloat.ReceiveValue(value);
		}
	}
	public static class RPCIntSender
	{
		public static bool SetValue(RPCInt rpcInt, int value)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return false;
			}
			if (RPCVariableExtender.Cache.TryGet(rpcInt, out var value2))
			{
				if (rpcInt.RequiresOwnership && !value2.IsOwner)
				{
					return false;
				}
			}
			else if (rpcInt.RequiresOwnership && !NetworkInfo.IsHost)
			{
				return false;
			}
			MessageRelay.RelayNative(RPCIntData.Create(ComponentPathData.CreateFromComponent<RPCVariable, RPCVariableExtender>((RPCVariable)rpcInt, RPCVariable.HashTable, RPCVariableExtender.Cache), value), NativeMessageTag.RPCInt, CommonMessageRoutes.ReliableToClients);
			return true;
		}

		public static void CatchupValue(RPCInt rpcInt, PlayerID playerID)
		{
			MessageRelay.RelayNative(RPCIntData.Create(ComponentPathData.CreateFromComponent<RPCVariable, RPCVariableExtender>((RPCVariable)rpcInt, RPCVariable.HashTable, RPCVariableExtender.Cache), rpcInt.GetLatestValue()), NativeMessageTag.RPCInt, new MessageRoute(playerID.SmallID, NetworkChannel.Reliable));
		}
	}
	public class RPCIntData : LabFusion.Network.Serialization.INetSerializable
	{
		public ComponentPathData PathData;

		public int Value;

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref PathData);
			serializer.SerializeValue(ref Value);
		}

		public static RPCIntData Create(ComponentPathData pathData, int value)
		{
			return new RPCIntData
			{
				PathData = pathData,
				Value = value
			};
		}
	}
	[Net.SkipHandleWhileLoading]
	public class RPCIntMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.RPCInt;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			RPCIntData rPCIntData = received.ReadData<RPCIntData>();
			if (rPCIntData.PathData.TryGetComponent<RPCVariable, RPCVariableExtender>(RPCVariable.HashTable, out RPCVariable component))
			{
				RPCInt rPCInt = ((Il2CppObjectBase)component).TryCast<RPCInt>();
				if (!((Object)(object)rPCInt == (Object)null))
				{
					OnFoundRPCInt(rPCInt, rPCIntData.Value);
				}
			}
		}

		private static void OnFoundRPCInt(RPCInt rpcInt, int value)
		{
			rpcInt.ReceiveValue(value);
		}
	}
	public class RPCMethodData : LabFusion.Network.Serialization.INetSerializable
	{
		public long MethodHash;

		public object[] Parameters;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref MethodHash);
			int value = 0;
			if (!serializer.IsReader)
			{
				value = Parameters.Length;
			}
			serializer.SerializeValue(ref value);
			if (serializer.IsReader)
			{
				Parameters = new object[value];
			}
			for (int i = 0; i < value; i++)
			{
				object value2 = Parameters[i];
				NetSerializerExtensions.SerializeValue(serializer, ref value2);
				Parameters[i] = value2;
			}
		}
	}
	public class RPCMethodMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.RPCMethod;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			RpcManager.InvokeMethod(received.ReadData<RPCMethodData>());
		}
	}
	public static class RPCStringSender
	{
		public static bool SetValue(RPCString rpcString, string value)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return false;
			}
			if (RPCVariableExtender.Cache.TryGet(rpcString, out var value2))
			{
				if (rpcString.RequiresOwnership && !value2.IsOwner)
				{
					return false;
				}
			}
			else if (rpcString.RequiresOwnership && !NetworkInfo.IsHost)
			{
				return false;
			}
			MessageRelay.RelayNative(RPCStringData.Create(ComponentPathData.CreateFromComponent<RPCVariable, RPCVariableExtender>((RPCVariable)rpcString, RPCVariable.HashTable, RPCVariableExtender.Cache), value), NativeMessageTag.RPCString, CommonMessageRoutes.ReliableToClients);
			return true;
		}

		public static void CatchupValue(RPCString rpcString, PlayerID playerID)
		{
			MessageRelay.RelayNative(RPCStringData.Create(ComponentPathData.CreateFromComponent<RPCVariable, RPCVariableExtender>((RPCVariable)rpcString, RPCVariable.HashTable, RPCVariableExtender.Cache), rpcString.GetLatestValue()), NativeMessageTag.RPCString, new MessageRoute(playerID.SmallID, NetworkChannel.Reliable));
		}
	}
	public class RPCStringData : LabFusion.Network.Serialization.INetSerializable
	{
		public ComponentPathData PathData;

		public string Value;

		public int? GetSize()
		{
			return 14 + Value.GetSize();
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref PathData);
			serializer.SerializeValue(ref Value);
		}

		public static RPCStringData Create(ComponentPathData pathData, string value)
		{
			return new RPCStringData
			{
				PathData = pathData,
				Value = value
			};
		}
	}
	[Net.SkipHandleWhileLoading]
	public class RPCStringMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.RPCString;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			RPCStringData rPCStringData = received.ReadData<RPCStringData>();
			if (rPCStringData.PathData.TryGetComponent<RPCVariable, RPCVariableExtender>(RPCVariable.HashTable, out RPCVariable component))
			{
				RPCString rPCString = ((Il2CppObjectBase)component).TryCast<RPCString>();
				if (!((Object)(object)rPCString == (Object)null))
				{
					OnFoundRPCString(rPCString, rPCStringData.Value);
				}
			}
		}

		private static void OnFoundRPCString(RPCString rpcString, string value)
		{
			rpcString.ReceiveValue(value);
		}
	}
	public static class RPCVector3Sender
	{
		public static bool SetValue(RPCVector3 rpcVector3, Vector3 value)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return false;
			}
			if (RPCVariableExtender.Cache.TryGet(rpcVector3, out var value2))
			{
				if (rpcVector3.RequiresOwnership && !value2.IsOwner)
				{
					return false;
				}
			}
			else if (rpcVector3.RequiresOwnership && !NetworkInfo.IsHost)
			{
				return false;
			}
			MessageRelay.RelayNative(RPCVector3Data.Create(ComponentPathData.CreateFromComponent<RPCVariable, RPCVariableExtender>((RPCVariable)rpcVector3, RPCVariable.HashTable, RPCVariableExtender.Cache), value), NativeMessageTag.RPCVector3, CommonMessageRoutes.ReliableToClients);
			return true;
		}

		public static void CatchupValue(RPCVector3 rpcVector3, PlayerID playerID)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			MessageRelay.RelayNative(RPCVector3Data.Create(ComponentPathData.CreateFromComponent<RPCVariable, RPCVariableExtender>((RPCVariable)rpcVector3, RPCVariable.HashTable, RPCVariableExtender.Cache), rpcVector3.GetLatestValue()), NativeMessageTag.RPCVector3, new MessageRoute(playerID.SmallID, NetworkChannel.Reliable));
		}
	}
	public class RPCVector3Data : LabFusion.Network.Serialization.INetSerializable
	{
		public ComponentPathData PathData;

		public Vector3 Value;

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref PathData);
			NetSerializerUnityExtensions.SerializeValue(serializer, ref Value);
		}

		public static RPCVector3Data Create(ComponentPathData pathData, Vector3 value)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return new RPCVector3Data
			{
				PathData = pathData,
				Value = value
			};
		}
	}
	[Net.SkipHandleWhileLoading]
	public class RPCVector3Message : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.RPCVector3;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			RPCVector3Data rPCVector3Data = received.ReadData<RPCVector3Data>();
			if (rPCVector3Data.PathData.TryGetComponent<RPCVariable, RPCVariableExtender>(RPCVariable.HashTable, out RPCVariable component))
			{
				RPCVector3 rPCVector = ((Il2CppObjectBase)component).TryCast<RPCVector3>();
				if (!((Object)(object)rPCVector == (Object)null))
				{
					OnFoundRPCVector3(rPCVector, rPCVector3Data.Value);
				}
			}
		}

		private static void OnFoundRPCVector3(RPCVector3 rpcVector3, Vector3 value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rpcVector3.ReceiveValue(value);
		}
	}
	public class ConnectionRequestData : LabFusion.Network.Serialization.INetSerializable
	{
		public ulong BackupPlatformID;

		public Version Version;

		public string AvatarBarcode;

		public SerializedAvatarStats AvatarStats;

		public Dictionary<string, string> InitialMetadata;

		public List<string> InitialEquippedItems;

		public bool IsValid { get; private set; } = true;


		public int? GetSize()
		{
			return 8 + Version.GetSize() + AvatarBarcode.GetSize() + 420 + InitialMetadata.GetSize() + InitialEquippedItems.GetSize();
		}

		public void Serialize(INetSerializer serializer)
		{
			try
			{
				serializer.SerializeValue(ref BackupPlatformID);
				NetSerializerExtensions.SerializeValue(serializer, ref Version);
				serializer.SerializeValue(ref AvatarBarcode);
				NetSerializerExtensions.SerializeValue(serializer, ref AvatarStats);
				NetSerializerExtensions.SerializeValue(serializer, ref InitialMetadata);
				NetSerializerExtensions.SerializeValue(serializer, ref InitialEquippedItems);
			}
			catch (Exception e)
			{
				IsValid = false;
				FusionLogger.LogException("serializing ConnectionRequestData", e);
			}
		}

		public static ConnectionRequestData Create(ulong longId, Version version, string avatarBarcode, SerializedAvatarStats stats)
		{
			LocalPlayer.InvokeApplyInitialMetadata();
			return new ConnectionRequestData
			{
				BackupPlatformID = longId,
				Version = version,
				AvatarBarcode = avatarBarcode,
				AvatarStats = stats,
				InitialMetadata = LocalPlayer.Metadata.Metadata.LocalDictionary,
				InitialEquippedItems = InternalServerHelpers.GetInitialEquippedItems()
			};
		}
	}
	public class ConnectionRequestMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.ConnectionRequest;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ServerOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			ConnectionRequestData connectionRequestData = received.ReadData<ConnectionRequestData>();
			ulong num = received.PlatformID ?? connectionRequestData.BackupPlatformID;
			byte? uniquePlayerID = PlayerIDManager.GetUniquePlayerID();
			if (!uniquePlayerID.HasValue)
			{
				ConnectionSender.SendConnectionDeny(num, "Server ran out of space! Wait for someone to leave.");
				return;
			}
			if (PlayerIDManager.GetPlayerID(num) != null)
			{
				ConnectionSender.SendConnectionDeny(num, "You attempted to join, but the server detects you as already in it?");
				return;
			}
			if (!connectionRequestData.IsValid)
			{
				ConnectionSender.SendConnectionDeny(num, "Connection request was invalid. You are likely on mismatching versions.");
				return;
			}
			if (PlayerIDManager.PlayerCount >= 255 || PlayerIDManager.PlayerCount >= SavedServerSettings.MaxPlayers.Value)
			{
				ConnectionSender.SendConnectionDeny(num, "Server is full! Wait for someone to leave.");
				return;
			}
			if (FusionSceneManager.IsLoading())
			{
				ConnectionSender.SendConnectionDeny(num, "Host is loading.");
				return;
			}
			if (!NetworkVerification.IsClientApproved(num))
			{
				ConnectionSender.SendConnectionDeny(num, "Server is private.");
				return;
			}
			switch (NetworkVerification.CompareVersion(FusionMod.Version, connectionRequestData.Version))
			{
			default:
				ConnectionSender.SendConnectionDeny(num, "Unknown Version Mismatch");
				break;
			case VersionResult.Lower:
				ConnectionSender.SendConnectionDeny(num, "Server is on an older version. Downgrade your version or notify the host.");
				break;
			case VersionResult.Higher:
				ConnectionSender.SendConnectionDeny(num, "Server is on a newer version. Update your version.");
				break;
			case VersionResult.Ok:
			{
				FusionPermissions.FetchPermissionLevel(num, out var level, out var _);
				if (NetworkHelper.IsBanned(num))
				{
					ConnectionSender.SendConnectionDeny(num, "Banned from Server");
					break;
				}
				GlobalBanInfo banInfo = GlobalBanManager.GetBanInfo(new PlatformInfo(num));
				if (banInfo != null && SavedServerSettings.Privacy.Value != ServerPrivacy.FRIENDS_ONLY)
				{
					ConnectionSender.SendConnectionDeny(num, banInfo.Reason);
					break;
				}
				connectionRequestData.InitialMetadata["PermissionLevel"] = level.ToString();
				PlayerID playerID = new PlayerID(num, uniquePlayerID.Value, connectionRequestData.InitialMetadata, connectionRequestData.InitialEquippedItems);
				if (!MultiplayerHooking.CheckShouldAllowConnection(playerID, out var reason))
				{
					ConnectionSender.SendConnectionDeny(num, reason);
				}
				else
				{
					OnConnectionAllowed(playerID, num, connectionRequestData);
				}
				break;
			}
			}
		}

		private static void OnConnectionAllowed(PlayerID playerID, ulong platformID, ConnectionRequestData data)
		{
			PlayerIDManager.ReserveSmallID(playerID.SmallID);
			ConnectionSender.SendPlayerJoin(playerID, data.AvatarBarcode, data.AvatarStats);
			foreach (PlayerID playerID2 in PlayerIDManager.PlayerIDs)
			{
				if (playerID2.SmallID == playerID.SmallID)
				{
					continue;
				}
				string avatar;
				SerializedAvatarStats stats;
				if (playerID2.SmallID == 0)
				{
					avatar = RigData.RigAvatarId;
					stats = RigData.RigAvatarStats;
				}
				else
				{
					if (!NetworkPlayerManager.TryGetPlayer(playerID2.SmallID, out var player))
					{
						continue;
					}
					avatar = player.AvatarSetter.AvatarBarcode;
					stats = player.AvatarSetter.AvatarStats;
				}
				ConnectionSender.SendPlayerCatchup(platformID, playerID2, avatar, stats);
			}
			LoadSender.SendLevelLoad(FusionSceneManager.Barcode, FusionSceneManager.LoadBarcode, platformID);
			DynamicsAssignData dynamicsAssignData = DynamicsAssignData.Create();
			using (NetWriter netWriter = NetWriter.Create(dynamicsAssignData.GetSize()))
			{
				dynamicsAssignData.Serialize(netWriter);
				using NetMessage message = NetMessage.Create(NativeMessageTag.DynamicsAssignment, netWriter, CommonMessageRoutes.None);
				MessageSender.SendFromServer(platformID, NetworkChannel.Reliable, message);
			}
			LobbyInfoManager.SendLobbyInfo(platformID);
		}
	}
	public class ConnectionResponseData : LabFusion.Network.Serialization.INetSerializable
	{
		public PlayerID PlayerID;

		public string AvatarBarcode;

		public SerializedAvatarStats AvatarStats;

		public bool IsInitialJoin;

		public int? GetSize()
		{
			return PlayerID.GetSize() + AvatarBarcode.GetSize() + 420 + 1;
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref PlayerID);
			serializer.SerializeValue(ref AvatarBarcode);
			NetSerializerExtensions.SerializeValue(serializer, ref AvatarStats);
			serializer.SerializeValue(ref IsInitialJoin);
		}

		public static ConnectionResponseData Create(PlayerID id, string avatarBarcode, SerializedAvatarStats stats, bool isInitialJoin)
		{
			return new ConnectionResponseData
			{
				PlayerID = id,
				AvatarBarcode = avatarBarcode,
				AvatarStats = stats,
				IsInitialJoin = isInitialJoin
			};
		}
	}
	public class ConnectionResponseMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.ConnectionResponse;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ClientsOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			ConnectionResponseData connectionResponseData = received.ReadData<ConnectionResponseData>();
			connectionResponseData.PlayerID.Insert();
			if (connectionResponseData.PlayerID.PlatformID == PlayerIDManager.LocalPlatformID)
			{
				PlayerIDManager.ApplyLocalID();
				NetworkPlayerManager.CreateLocalPlayer();
				InternalServerHelpers.OnJoinServer();
			}
			else
			{
				InternalServerHelpers.OnPlayerJoined(connectionResponseData.PlayerID, connectionResponseData.IsInitialJoin);
				NetworkPlayerManager.CreateNetworkPlayer(connectionResponseData.PlayerID).AvatarSetter.SwapAvatar(connectionResponseData.AvatarStats, connectionResponseData.AvatarBarcode);
			}
			if (NetworkInfo.IsHost)
			{
				CatchupPlayer(connectionResponseData.PlayerID);
			}
		}

		private static void CatchupPlayer(PlayerID player)
		{
			CatchupManager.InvokePlayerServerCatchup(player);
		}
	}
	public class DisconnectMessageData : LabFusion.Network.Serialization.INetSerializable
	{
		public ulong PlatformID;

		public string Reason;

		public static DisconnectMessageData Create(ulong longId, string reason = "")
		{
			return new DisconnectMessageData
			{
				PlatformID = longId,
				Reason = reason
			};
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref PlatformID);
			serializer.SerializeValue(ref Reason);
		}
	}
	public class DisconnectMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.Disconnect;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ClientsOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			DisconnectMessageData disconnectMessageData = received.ReadData<DisconnectMessageData>();
			if (disconnectMessageData.PlatformID == PlayerIDManager.LocalPlatformID)
			{
				NetworkHelper.Disconnect(disconnectMessageData.Reason);
			}
			else
			{
				InternalServerHelpers.OnPlayerLeft(disconnectMessageData.PlatformID);
			}
		}
	}
	public enum PermissionCommandType
	{
		UNKNOWN,
		KICK,
		BAN,
		TELEPORT_TO_THEM,
		TELEPORT_TO_ME
	}
	public class PermissionCommandRequestData : LabFusion.Network.Serialization.INetSerializable
	{
		public PermissionCommandType Type;

		public byte? OtherPlayer;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Type, Precision.OneByte);
			serializer.SerializeValue(ref OtherPlayer);
		}
	}
	public class PermissionCommandRequestMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PermissionCommandRequest;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ServerOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			PermissionCommandRequestData permissionCommandRequestData = received.ReadData<PermissionCommandRequestData>();
			byte? sender = received.Sender;
			if (!sender.HasValue)
			{
				return;
			}
			PlayerID playerID = PlayerIDManager.GetPlayerID(sender.Value);
			PlayerID playerID2 = null;
			if (permissionCommandRequestData.OtherPlayer.HasValue)
			{
				playerID2 = PlayerIDManager.GetPlayerID(permissionCommandRequestData.OtherPlayer.Value);
			}
			FusionPermissions.FetchPermissionLevel(playerID, out var level, out var _);
			switch (permissionCommandRequestData.Type)
			{
			case PermissionCommandType.KICK:
				if (!playerID2.IsHost && playerID2 != null && FusionPermissions.HasSufficientPermissions(level, LobbyInfoManager.LobbyInfo.Kicking))
				{
					NetworkHelper.KickUser(playerID2);
				}
				break;
			case PermissionCommandType.BAN:
				if (!playerID2.IsHost && playerID2 != null && FusionPermissions.HasSufficientPermissions(level, LobbyInfoManager.LobbyInfo.Banning))
				{
					NetworkHelper.BanUser(playerID2);
				}
				break;
			case PermissionCommandType.TELEPORT_TO_THEM:
				if (playerID2 != null && FusionPermissions.HasSufficientPermissions(level, LobbyInfoManager.LobbyInfo.Teleportation))
				{
					PlayerRepUtilities.TryGetReferences(playerID2, out var references2);
					if (references2 != null && references2.IsValid)
					{
						PlayerSender.SendPlayerTeleport(playerID, references2.RigManager.physicsRig.feet.transform.position);
					}
				}
				break;
			case PermissionCommandType.TELEPORT_TO_ME:
				if (playerID2 != null && FusionPermissions.HasSufficientPermissions(level, LobbyInfoManager.LobbyInfo.Teleportation))
				{
					PlayerRepUtilities.TryGetReferences(playerID, out var references);
					if (references != null && references.IsValid)
					{
						PlayerSender.SendPlayerTeleport(playerID2, references.RigManager.physicsRig.feet.transform.position);
					}
				}
				break;
			case PermissionCommandType.UNKNOWN:
				break;
			}
		}
	}
	public class PlayerMetadataRequestMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PlayerMetadataRequest;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ServerOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			PlayerMetadataData playerMetadataData = received.ReadData<PlayerMetadataData>();
			if (!NetworkVerification.HasAuthorityOverPlayer(playerMetadataData.Player.ID, received.Sender))
			{
				string value = (received.PlatformID.HasValue ? $"{received.PlatformID}" : "with no PlatformID");
				FusionLogger.Warn($"User {value} attempted to modify metadata for player {playerMetadataData.Player.ID}!");
			}
			else
			{
				PlayerSender.SendPlayerMetadataResponse(playerMetadataData.Player.ID, playerMetadataData.Key, playerMetadataData.Value);
			}
		}
	}
	public class PlayerMetadataResponseMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PlayerMetadataResponse;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ClientsOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			PlayerMetadataData playerMetadataData = received.ReadData<PlayerMetadataData>();
			playerMetadataData.Player.GetPlayer()?.Metadata.Metadata.ForceSetLocalMetadata(playerMetadataData.Key, playerMetadataData.Value);
		}
	}
	public class PlayerSettingsData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 16;

		public SerializedPlayerSettings Settings;

		public int? GetSize()
		{
			return 16;
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref Settings);
		}
	}
	public class PlayerSettingsMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PlayerSettings;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			PlayerSettingsData playerSettingsData = received.ReadData<PlayerSettingsData>();
			byte? sender = received.Sender;
			if (sender.HasValue && NetworkPlayerManager.TryGetPlayer(sender.Value, out var player))
			{
				player.SetSettings(playerSettingsData.Settings);
			}
		}
	}
	public class PlayerVoiceChatData : LabFusion.Network.Serialization.INetSerializable
	{
		public byte[] Bytes;

		public int? GetSize()
		{
			return 4 + Bytes.Length;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Bytes);
		}
	}
	public class PlayerVoiceChatMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.PlayerVoiceChat;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			PlayerVoiceChatData playerVoiceChatData = received.ReadData<PlayerVoiceChatData>();
			byte? sender = received.Sender;
			if (sender.HasValue && !VoiceInfo.IsDeafened)
			{
				PlayerID playerID = PlayerIDManager.GetPlayerID(sender.Value);
				if (playerID != null)
				{
					VoiceHelper.OnVoiceDataReceived(playerID, playerVoiceChatData.Bytes);
				}
			}
		}
	}
	public class ServerSettingsData : LabFusion.Network.Serialization.INetSerializable
	{
		public LobbyInfo LobbyInfo;

		public int? GetSize()
		{
			return SerializeJson().GetSize();
		}

		public void Serialize(INetSerializer serializer)
		{
			if (serializer is NetWriter writer)
			{
				Serialize(writer);
			}
			else if (serializer is NetReader reader)
			{
				Deserialize(reader);
			}
		}

		private string SerializeJson()
		{
			return JsonSerializer.Serialize(LobbyInfo);
		}

		public void Serialize(NetWriter writer)
		{
			writer.Write(SerializeJson());
		}

		public void Deserialize(NetReader reader)
		{
			LobbyInfo = JsonSerializer.Deserialize<LobbyInfo>(reader.ReadString());
		}

		public static ServerSettingsData Create()
		{
			return new ServerSettingsData
			{
				LobbyInfo = LobbyInfoManager.LobbyInfo
			};
		}
	}
	public class ServerSettingsMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.ServerSettings;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ClientsOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			LobbyInfoManager.LobbyInfo = received.ReadData<ServerSettingsData>().LobbyInfo;
		}
	}
	public class DespawnRequestData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 3;

		public NetworkEntityReference Entity;

		public bool DespawnEffect;

		public int? GetSize()
		{
			return 3;
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref Entity);
			serializer.SerializeValue(ref DespawnEffect);
		}
	}
	[Net.DelayWhileTargetLoading]
	public class DespawnRequestMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.DespawnRequest;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ServerOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			DespawnRequestData despawnRequestData = received.ReadData<DespawnRequestData>();
			MessageRelay.RelayNative(new DespawnResponseData
			{
				Despawner = new PlayerReference(received.Sender.Value),
				Entity = despawnRequestData.Entity,
				DespawnEffect = despawnRequestData.DespawnEffect
			}, NativeMessageTag.DespawnResponse, CommonMessageRoutes.ReliableToClients);
		}
	}
	public class DespawnResponseData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 4;

		public PlayerReference Despawner;

		public NetworkEntityReference Entity;

		public bool DespawnEffect;

		public int? GetSize()
		{
			return 4;
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerExtensions.SerializeValue(serializer, ref Despawner);
			NetSerializerExtensions.SerializeValue(serializer, ref Entity);
			serializer.SerializeValue(ref DespawnEffect);
		}
	}
	[Net.DelayWhileTargetLoading]
	public class DespawnResponseMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.DespawnResponse;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ClientsOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			DespawnResponseData despawnResponseData = received.ReadData<DespawnResponseData>();
			if (!despawnResponseData.Entity.TryGetEntity(out var entity) || entity.GetExtender<NetworkPlayer>() != null)
			{
				return;
			}
			PooleeExtender extender = entity.GetExtender<PooleeExtender>();
			if (extender != null)
			{
				PooleeDespawnPatch.IgnorePatch = true;
				Poolee component = extender.Component;
				IMarrowEntityExtender extender2 = entity.GetExtender<IMarrowEntityExtender>();
				if (extender2 != null && despawnResponseData.DespawnEffect)
				{
					SpawnEffects.CallDespawnEffect(extender2.MarrowEntity);
				}
				component.Despawn();
				NetworkEntityManager.IDManager.UnregisterEntity(entity);
				PooleeDespawnPatch.IgnorePatch = false;
			}
		}
	}
	[Net.DelayWhileTargetLoading]
	public class SpawnRequestMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.SpawnRequest;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ServerOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			SerializedSpawnData serializedSpawnData = received.ReadData<SerializedSpawnData>();
			if (!ModBlacklist.IsBlacklisted(serializedSpawnData.Barcode) && !GlobalModBlacklistManager.IsBarcodeBlacklisted(serializedSpawnData.Barcode) && !CrateFilterer.HasTags<SpawnableCrate>(new Barcode(serializedSpawnData.Barcode), new string[1] { "Singleplayer Only" }))
			{
				ushort entityID = NetworkEntityManager.IDManager.RegisteredEntities.AllocateNewID();
				MessageRelay.RelayNative(new SpawnResponseData
				{
					OwnerID = received.Sender.Value,
					EntityID = entityID,
					SpawnData = serializedSpawnData
				}, NativeMessageTag.SpawnResponse, CommonMessageRoutes.ReliableToClients);
			}
		}
	}
	public class SpawnResponseData : LabFusion.Network.Serialization.INetSerializable
	{
		public byte OwnerID;

		public ushort EntityID;

		public SerializedSpawnData SpawnData;

		public int? GetSize()
		{
			return 3 + SpawnData.GetSize();
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref OwnerID);
			serializer.SerializeValue(ref EntityID);
			NetSerializerExtensions.SerializeValue(serializer, ref SpawnData);
		}
	}
	[Net.DelayWhileTargetLoading]
	public class SpawnResponseMessage : NativeMessageHandler
	{
		public override byte Tag => NativeMessageTag.SpawnResponse;

		public override ExpectedReceiverType ExpectedReceiver => ExpectedReceiverType.ClientsOnly;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			SpawnResponseData data = received.ReadData<SpawnResponseData>();
			SerializedSpawnData spawnData = data.SpawnData;
			byte ownerID = data.OwnerID;
			string barcode = spawnData.Barcode;
			_ = data.EntityID;
			_ = spawnData.TrackerID;
			_ = spawnData.SpawnEffect;
			if (ModBlacklist.IsBlacklisted(barcode) || GlobalModBlacklistManager.IsBarcodeBlacklisted(barcode))
			{
				return;
			}
			if (!CrateFilterer.HasCrate<SpawnableCrate>(new Barcode(barcode)))
			{
				if (ClientSettings.Downloading.DownloadSpawnables.Value)
				{
					long value = DataConversions.ConvertMegabytesToBytes(ClientSettings.Downloading.MaxFileSize.Value);
					NetworkModRequester.ModInstallInfo installInfo = default(NetworkModRequester.ModInstallInfo);
					installInfo.Target = ownerID;
					installInfo.Barcode = barcode;
					installInfo.FinishDownloadCallback = OnModDownloaded;
					installInfo.MaxBytes = value;
					NetworkModRequester.RequestAndInstallMod(installInfo);
				}
			}
			else
			{
				BeginSpawn();
			}
			void BeginSpawn()
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(barcode);
				LocalAssetSpawner.Register(spawnable);
				LocalAssetSpawner.Spawn(spawnable, spawnData.SerializedTransform.position, spawnData.SerializedTransform.rotation, OnPooleeSpawned);
			}
			void OnModDownloaded(DownloadCallbackInfo info)
			{
				if (info.Result != ModResult.SUCCEEDED)
				{
					FusionLogger.Warn("Failed downloading spawnable " + barcode + "!");
				}
				else
				{
					BeginSpawn();
				}
			}
			void OnPooleeSpawned(Poolee poolee)
			{
				OnSpawnFinished(data, poolee);
			}
		}

		public static void OnSpawnFinished(SpawnResponseData data, Poolee poolee)
		{
			GameObject gameObject = ((Component)poolee).gameObject;
			if (PooleeExtender.Cache.TryGet(poolee, out var value))
			{
				FusionLogger.Warn($"Unregistered entity {value.ID} on poolee {((Object)poolee).name} due to conflicting id.");
				NetworkEntityManager.IDManager.UnregisterEntity(value);
			}
			NetworkEntity entity = null;
			MarrowEntity val = MarrowEntity.Cache.Get(gameObject);
			if ((Object)(object)val != (Object)null)
			{
				if (!SpawnableBlacklist.IsClientSide(data.SpawnData.Barcode))
				{
					entity = CreateNetworkEntity(gameObject, data.SpawnData.Barcode, val, data.OwnerID, data.EntityID, data.SpawnData.SpawnSource);
				}
				if (data.SpawnData.SpawnEffect)
				{
					SpawnEffects.CallSpawnEffect(val);
				}
			}
			if (data.OwnerID == PlayerIDManager.LocalSmallID)
			{
				NetworkAssetSpawner.OnSpawnComplete(data.SpawnData.TrackerID, new NetworkAssetSpawner.SpawnCallbackInfo
				{
					Spawned = gameObject,
					Entity = entity
				});
			}
		}

		private static NetworkEntity CreateNetworkEntity(GameObject gameObject, string barcode, MarrowEntity marrowEntity, byte ownerID, ushort entityID, EntitySource source)
		{
			PlayerID playerID = PlayerIDManager.GetPlayerID(ownerID);
			NetworkEntity networkEntity = new NetworkEntity
			{
				Source = source
			};
			networkEntity.SetOwner(playerID);
			new NetworkProp(networkEntity, marrowEntity);
			NetworkEntityManager.IDManager.RegisterEntity(entityID, networkEntity);
			networkEntity.OnEntityCreationCatchup += delegate(NetworkEntity entity, PlayerID player)
			{
				SpawnSender.SendCatchupSpawn(ownerID, barcode, entityID, new SerializedTransform(gameObject.transform), player, source);
			};
			CatchupManager.RequestEntityDataCatchup(new NetworkEntityReference(networkEntity));
			return networkEntity;
		}
	}
	public static class NetworkConnectionManager
	{
		private class DisconnectTimeout
		{
			public ulong PlatformID;

			public float TimeRemaining;
		}

		private static readonly List<DisconnectTimeout> _disconnectTimeouts = new List<DisconnectTimeout>();

		public static void TimeoutDisconnect(ulong platformID, float duration = 1f)
		{
			if (NetworkInfo.IsHost)
			{
				_disconnectTimeouts.Add(new DisconnectTimeout
				{
					PlatformID = platformID,
					TimeRemaining = duration
				});
			}
		}

		public static void DisconnectUser(ulong platformID)
		{
			if (NetworkInfo.IsHost)
			{
				NetworkInfo.Layer.DisconnectUser(platformID);
			}
		}

		internal static void OnUpdate(float deltaTime)
		{
			ProcessDisconnectTimeouts(deltaTime);
		}

		private static void ProcessDisconnectTimeouts(float deltaTime)
		{
			for (int num = _disconnectTimeouts.Count - 1; num >= 0; num--)
			{
				DisconnectTimeout disconnectTimeout = _disconnectTimeouts[num];
				disconnectTimeout.TimeRemaining -= deltaTime;
				if (disconnectTimeout.TimeRemaining <= 0f)
				{
					DisconnectUser(disconnectTimeout.PlatformID);
					_disconnectTimeouts.RemoveAt(num);
				}
			}
		}
	}
	public static class NetworkNotifications
	{
		public const string NotificationTag = "Network";

		public static void SendStartedServerNotification()
		{
			Notifier.Cancel("Network");
			Notifier.Send(new Notification
			{
				Title = "Started Server",
				Message = "Started a server!",
				Tag = "Network",
				SaveToMenu = false,
				ShowPopup = true,
				Type = NotificationType.SUCCESS
			});
		}

		public static void SendJoinedServerNotification()
		{
			Notifier.Cancel("Network");
			Notifier.Send(new Notification
			{
				Title = "Joined Server",
				Message = "Joined a server!",
				Tag = "Network",
				SaveToMenu = false,
				ShowPopup = true,
				Type = NotificationType.SUCCESS
			});
		}

		public static void SendDisconnectedNotification()
		{
			SendDisconnectedNotification(null);
		}

		public static void SendDisconnectedNotification(string reason)
		{
			Notifier.Cancel("Network");
			if (string.IsNullOrWhiteSpace(reason))
			{
				Notifier.Send(new Notification
				{
					Title = "Disconnected from Server",
					Message = "Disconnected from the current server!",
					Tag = "Network",
					SaveToMenu = false,
					ShowPopup = true
				});
			}
			else
			{
				Notifier.Send(new Notification
				{
					Title = "Disconnected from Server",
					Message = "You were disconnected for reason: " + reason,
					Tag = "Network",
					SaveToMenu = true,
					ShowPopup = true,
					PopupLength = 5f,
					Type = NotificationType.WARNING
				});
			}
		}

		public static void SendPlayerJoinedNotification(string name)
		{
			Notifier.Cancel("Network");
			Notifier.Send(new Notification
			{
				Title = name + " Joined",
				Message = name + " joined the server.",
				Tag = "Network",
				SaveToMenu = false,
				ShowPopup = true
			});
		}

		public static void SendPlayerLeftNotification(string name)
		{
			Notifier.Cancel("Network");
			Notifier.Send(new Notification
			{
				Title = name + " Left",
				Message = name + " left the server.",
				Tag = "Network",
				SaveToMenu = false,
				ShowPopup = true
			});
		}
	}
	public static class NetworkTickManager
	{
		public static readonly float TickRate = 20f;

		public static readonly float SecondsBetweenTicks = 1f / TickRate;

		public static readonly float InterpolationDecayRate = 36f;

		private static float _tickElapsed = 0f;

		public static bool IsTickThisFrame { get; private set; } = false;


		public static float InterpolationTime { get; private set; } = 0f;


		internal static void OnUpdate(float deltaTime)
		{
			IsTickThisFrame = false;
			InterpolationTime = Smoothing.CalculateDecay(InterpolationDecayRate, deltaTime);
			_tickElapsed += deltaTime;
			if (_tickElapsed >= SecondsBetweenTicks)
			{
				_tickElapsed -= SecondsBetweenTicks;
				IsTickThisFrame = true;
			}
		}
	}
	public static class RandomCodeGenerator
	{
		public const string StringCharacters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

		public static string GetString(int length)
		{
			return new string((from s in Enumerable.Repeat("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", length)
				select s[RandomNumberGenerator.GetInt32(s.Length)]).ToArray());
		}
	}
}
namespace LabFusion.Network.Serialization
{
	public interface INetSerializable
	{
		int? GetSize()
		{
			return null;
		}

		void Serialize(INetSerializer serializer);
	}
	public interface INetSerializer
	{
		bool IsReader { get; }

		void SerializeValue(ref byte value);

		void SerializeValue(ref bool value);

		void SerializeValue(ref double value);

		void SerializeValue(ref short value);

		void SerializeValue(ref int value);

		void SerializeValue(ref long value);

		void SerializeValue(ref sbyte value);

		void SerializeValue(ref float value);

		void SerializeValue(ref ushort value);

		void SerializeValue(ref uint value);

		void SerializeValue(ref ulong value);

		void SerializeValue(ref string value);

		void SerializeValue(ref byte[] value);

		void SerializeValue(ref ArraySegment<byte> value);

		void SerializeValue(ref string[] value);

		void SerializeValue<TEnum>(ref TEnum value) where TEnum : struct, Enum;

		void SerializeValue<TEnum>(ref TEnum value, Precision precision) where TEnum : struct, Enum;

		void SerializeValue(ref byte? value);

		void SerializeValue(ref int? value);

		void SerializeValue(ref ushort? value);
	}
	public sealed class NetReader : INetSerializer, IDisposable
	{
		private byte[] _buffer;

		public bool IsReader => true;

		public int Position { get; set; }

		public int Length { get; set; }

		public static NetReader Create(byte[] buffer)
		{
			return new NetReader
			{
				_buffer = buffer,
				Position = 0,
				Length = buffer.Length
			};
		}

		public byte ReadByte()
		{
			if (Position >= Length)
			{
				throw new IndexOutOfRangeException($"Failed to read as the reader does not have enough data remaining. Expected 1 byte but reader only has {Length - Position} bytes remaining.");
			}
			return _buffer[Position++];
		}

		public bool ReadBoolean()
		{
			return ReadByte() == 1;
		}

		public double ReadDouble()
		{
			if (Position + 8 > Length)
			{
				throw new IndexOutOfRangeException($"Failed to read data from reader as the reader does not have enough data remaining. Expected 8 bytes but reader only has {Length - Position} bytes remaining.");
			}
			double result = BinaryPrimitives.ReadDoubleBigEndian(new ReadOnlySpan<byte>(_buffer, Position, 8));
			Position += 8;
			return result;
		}

		public short ReadInt16()
		{
			if (Position + 2 > Length)
			{
				throw new IndexOutOfRangeException($"Failed to read data from reader as the reader does not have enough data remaining. Expected 2 bytes but reader only has {Length - Position} bytes remaining.");
			}
			short result = BinaryPrimitives.ReadInt16BigEndian(new ReadOnlySpan<byte>(_buffer, Position, 2));
			Position += 2;
			return result;
		}

		public int ReadInt32()
		{
			if (Position + 4 > Length)
			{
				throw new IndexOutOfRangeException($"Failed to read data from reader as the reader does not have enough data remaining. Expected 4 bytes but reader only has {Length - Position} bytes remaining.");
			}
			int result = BinaryPrimitives.ReadInt32BigEndian(new ReadOnlySpan<byte>(_buffer, Position, 4));
			Position += 4;
			return result;
		}

		public long ReadInt64()
		{
			if (Position + 8 > Length)
			{
				throw new IndexOutOfRangeException($"Failed to read data from reader as the reader does not have enough data remaining. Expected 8 bytes but reader only has {Length - Position} bytes remaining.");
			}
			long result = BinaryPrimitives.ReadInt64BigEndian(new ReadOnlySpan<byte>(_buffer, Position, 8));
			Position += 8;
			return result;
		}

		public sbyte ReadSByte()
		{
			return ReadByte().ToSByte();
		}

		public float ReadSingle()
		{
			if (Position + 4 > Length)
			{
				throw new IndexOutOfRangeException($"Failed to read data from reader as the reader does not have enough data remaining. Expected 4 bytes but reader only has {Length - Position} bytes remaining.");
			}
			float result = BinaryPrimitives.ReadSingleBigEndian(new ReadOnlySpan<byte>(_buffer, Position, 4));
			Position += 4;
			return result;
		}

		public string ReadString()
		{
			return ReadString(Encoding.UTF8);
		}

		public string ReadString(Encoding encoding)
		{
			int num = ReadInt32();
			if (num <= -1)
			{
				return null;
			}
			if (Position + num > Length)
			{
				throw new IndexOutOfRangeException($"Failed to read data from reader as the reader does not have enough data remaining. Expected {num} bytes but reader only has {Length - Position - 4} bytes remaining.");
			}
			string @string = encoding.GetString(_buffer, Position, num);
			Position += num;
			return @string;
		}

		public ushort ReadUInt16()
		{
			if (Position + 2 > Length)
			{
				throw new IndexOutOfRangeException($"Failed to read data from reader as the reader does not have enough data remaining. Expected 2 bytes but reader only has {Length - Position} bytes remaining.");
			}
			ushort result = BinaryPrimitives.ReadUInt16BigEndian(new ReadOnlySpan<byte>(_buffer, Position, 2));
			Position += 2;
			return result;
		}

		public uint ReadUInt32()
		{
			if (Position + 4 > Length)
			{
				throw new IndexOutOfRangeException($"Failed to read data from reader as the reader does not have enough data remaining. Expected 4 bytes but reader only has {Length - Position} bytes remaining.");
			}
			uint result = BinaryPrimitives.ReadUInt32BigEndian(new ReadOnlySpan<byte>(_buffer, Position, 4));
			Position += 4;
			return result;
		}

		public ulong ReadUInt64()
		{
			if (Position + 8 > Length)
			{
				throw new IndexOutOfRangeException($"Failed to read data from reader as the reader does not have enough data remaining. Expected 8 bytes but reader only has {Length - Position} bytes remaining.");
			}
			ulong result = BinaryPrimitives.ReadUInt64BigEndian(new ReadOnlySpan<byte>(_buffer, Position, 8));
			Position += 8;
			return result;
		}

		public byte[] ReadBytes()
		{
			int num = ReadInt32();
			if (Position + num > Length)
			{
				throw new IndexOutOfRangeException($"Failed to read data from reader as the reader does not have enough data remaining. Expected {num} bytes but reader only has {Length - Position - 4} bytes remaining.");
			}
			byte[] array = new byte[num];
			Buffer.BlockCopy(_buffer, Position, array, 0, num);
			Position += num;
			return array;
		}

		public string[] ReadStrings()
		{
			int num = ReadInt32();
			string[] array = new string[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = ReadString();
			}
			return array;
		}

		public TEnum ReadEnum<TEnum>() where TEnum : struct, Enum
		{
			return EnumConverter.ConvertToEnum<TEnum>(ReadInt32());
		}

		public TEnum ReadEnum<TEnum>(Precision precision) where TEnum : struct, Enum
		{
			return precision switch
			{
				Precision.TwoBytes => EnumConverter.ConvertToEnum<TEnum>(ReadInt16()), 
				Precision.OneByte => EnumConverter.ConvertToEnum<TEnum>(ReadByte()), 
				_ => EnumConverter.ConvertToEnum<TEnum>(ReadInt32()), 
			};
		}

		public byte? ReadByteNullable()
		{
			if (ReadBoolean())
			{
				return ReadByte();
			}
			return null;
		}

		public ushort? ReadUInt16Nullable()
		{
			if (ReadBoolean())
			{
				return ReadUInt16();
			}
			return null;
		}

		public int? ReadInt32Nullable()
		{
			if (ReadBoolean())
			{
				return ReadInt32();
			}
			return null;
		}

		public void SerializeValue(ref byte value)
		{
			value = ReadByte();
		}

		public void SerializeValue(ref bool value)
		{
			value = ReadBoolean();
		}

		public void SerializeValue(ref int value)
		{
			value = ReadInt32();
		}

		public void SerializeValue(ref double value)
		{
			value = ReadDouble();
		}

		public void SerializeValue(ref short value)
		{
			value = ReadInt16();
		}

		public void SerializeValue(ref long value)
		{
			value = ReadInt64();
		}

		public void SerializeValue(ref sbyte value)
		{
			value = ReadSByte();
		}

		public void SerializeValue(ref float value)
		{
			value = ReadSingle();
		}

		public void SerializeValue(ref ushort value)
		{
			value = ReadUInt16();
		}

		public void SerializeValue(ref uint value)
		{
			value = ReadUInt32();
		}

		public void SerializeValue(ref ulong value)
		{
			value = ReadUInt64();
		}

		public void SerializeValue(ref string value)
		{
			value = ReadString();
		}

		public void SerializeValue(ref byte[] value)
		{
			value = ReadBytes();
		}

		public void SerializeValue(ref ArraySegment<byte> value)
		{
			value = ReadBytes();
		}

		public void SerializeValue(ref string[] value)
		{
			value = ReadStrings();
		}

		public void SerializeValue<TEnum>(ref TEnum value) where TEnum : struct, Enum
		{
			value = ReadEnum<TEnum>();
		}

		public void SerializeValue<TEnum>(ref TEnum value, Precision precision) where TEnum : struct, Enum
		{
			value = ReadEnum<TEnum>(precision);
		}

		public void SerializeValue(ref byte? value)
		{
			value = ReadByteNullable();
		}

		public void SerializeValue(ref ushort? value)
		{
			value = ReadUInt16Nullable();
		}

		public void SerializeValue(ref int? value)
		{
			value = ReadInt32Nullable();
		}

		public void Dispose()
		{
			GC.SuppressFinalize(this);
		}
	}
	public static class NetSerializerExtensions
	{
		public static void SerializeValueByJson(this INetSerializer serializer, ref object value)
		{
			if (SerializeNullable(serializer, ref value))
			{
				Type type = SerializeType(serializer, ref value);
				SerializeJson(serializer, ref value, type);
			}
		}

		private static Type SerializeType(INetSerializer serializer, ref object value)
		{
			string value2 = null;
			if (!serializer.IsReader)
			{
				value2 = value.GetType().AssemblyQualifiedName;
			}
			serializer.SerializeValue(ref value2);
			return Type.GetType(value2);
		}

		private static bool SerializeNullable(INetSerializer serializer, ref object value)
		{
			bool value2 = value != null;
			serializer.SerializeValue(ref value2);
			if (!value2)
			{
				return false;
			}
			return true;
		}

		private static void SerializeJson(INetSerializer serializer, ref object value, Type type)
		{
			JsonSerializerOptions options = new JsonSerializerOptions
			{
				IncludeFields = true,
				IgnoreReadOnlyFields = true,
				IgnoreReadOnlyProperties = true
			};
			byte[] value2 = JsonSerializer.SerializeToUtf8Bytes(value, options);
			serializer.SerializeValue(ref value2);
			if (serializer.IsReader)
			{
				value = JsonSerializer.Deserialize(value2, type, options);
			}
		}

		public static void SerializeValue(this INetSerializer serializer, ref object value)
		{
			if (!SerializeNullable(serializer, ref value))
			{
				return;
			}
			Type type = SerializeType(serializer, ref value);
			if (type == typeof(int))
			{
				int value2 = (int)value;
				serializer.SerializeValue(ref value2);
				value = value2;
			}
			else if (type == typeof(uint))
			{
				uint value3 = (uint)value;
				serializer.SerializeValue(ref value3);
				value = value3;
			}
			else if (type == typeof(short))
			{
				short value4 = (short)value;
				serializer.SerializeValue(ref value4);
				value = value4;
			}
			else if (type == typeof(ushort))
			{
				ushort value5 = (ushort)value;
				serializer.SerializeValue(ref value5);
				value = value5;
			}
			else if (type == typeof(long))
			{
				long value6 = (long)value;
				serializer.SerializeValue(ref value6);
				value = value6;
			}
			else if (type == typeof(ulong))
			{
				ulong value7 = (ulong)value;
				serializer.SerializeValue(ref value7);
				value = value7;
			}
			else if (type == typeof(double))
			{
				double value8 = (double)value;
				serializer.SerializeValue(ref value8);
				value = value8;
			}
			else if (type == typeof(bool))
			{
				bool value9 = (bool)value;
				serializer.SerializeValue(ref value9);
				value = value9;
			}
			else if (type == typeof(byte))
			{
				byte value10 = (byte)value;
				serializer.SerializeValue(ref value10);
				value = value10;
			}
			else if (type == typeof(sbyte))
			{
				sbyte value11 = (sbyte)value;
				serializer.SerializeValue(ref value11);
				value = value11;
			}
			else if (type == typeof(byte?))
			{
				byte? value12 = value as byte?;
				serializer.SerializeValue(ref value12);
				value = value12;
			}
			else if (type == typeof(ushort?))
			{
				ushort? value13 = value as ushort?;
				serializer.SerializeValue(ref value13);
				value = value13;
			}
			else if (type == typeof(byte[]))
			{
				byte[] value14 = value as byte[];
				serializer.SerializeValue(ref value14);
				value = value14;
			}
			else if (type == typeof(string))
			{
				string value15 = value as string;
				serializer.SerializeValue(ref value15);
				value = value15;
			}
			else if (type.IsAssignableTo(typeof(INetSerializable)))
			{
				INetSerializable value16 = value as INetSerializable;
				serializer.SerializeValue(ref value16, type);
				if (serializer.IsReader)
				{
					value = value16;
				}
			}
			else
			{
				if (!type.IsValueType && !type.IsSerializable)
				{
					throw new NotSupportedException("Serialization of type " + type.FullName + " is not supported.");
				}
				SerializeJson(serializer, ref value, type);
			}
		}

		public static void SerializeValue<TSerializable>(this INetSerializer serializer, ref TSerializable value) where TSerializable : INetSerializable, new()
		{
			if (serializer.IsReader)
			{
				value = new TSerializable();
			}
			value.Serialize(serializer);
		}

		public static void SerializeValue(this INetSerializer serializer, ref INetSerializable value, Type type)
		{
			if (serializer.IsReader)
			{
				value = Activator.CreateInstance(type) as INetSerializable;
			}
			value.Serialize(serializer);
		}

		public static void SerializeValue(this INetSerializer serializer, ref Version value)
		{
			int value2 = 0;
			int value3 = 0;
			int value4 = 0;
			if (!serializer.IsReader)
			{
				value2 = value.Major;
				value3 = value.Minor;
				value4 = value.Build;
			}
			serializer.SerializeValue(ref value2);
			serializer.SerializeValue(ref value3);
			serializer.SerializeValue(ref value4);
			if (serializer.IsReader)
			{
				value = new Version(value2, value3, value4);
			}
		}

		public static void SerializeValue(this INetSerializer serializer, ref Dictionary<string, string> value)
		{
			int value2 = 0;
			if (!serializer.IsReader)
			{
				value2 = value.Count;
			}
			serializer.SerializeValue(ref value2);
			if (serializer.IsReader)
			{
				value = new Dictionary<string, string>(value2);
				for (int i = 0; i < value2; i++)
				{
					string value3 = null;
					string value4 = null;
					serializer.SerializeValue(ref value3);
					serializer.SerializeValue(ref value4);
					value.Add(value3, value4);
				}
				return;
			}
			foreach (KeyValuePair<string, string> item in value)
			{
				string value5 = item.Key;
				string value6 = item.Value;
				serializer.SerializeValue(ref value5);
				serializer.SerializeValue(ref value6);
			}
		}

		public static void SerializeValue(this INetSerializer serializer, ref List<string> value)
		{
			int value2 = 0;
			if (!serializer.IsReader)
			{
				value2 = value.Count;
			}
			serializer.SerializeValue(ref value2);
			if (serializer.IsReader)
			{
				value = new List<string>(value2);
				for (int i = 0; i < value2; i++)
				{
					string value3 = null;
					serializer.SerializeValue(ref value3);
					value.Add(value3);
				}
			}
			else
			{
				for (int j = 0; j < value2; j++)
				{
					string value4 = value[j];
					serializer.SerializeValue(ref value4);
				}
			}
		}
	}
	public static class NetSerializerUnityExtensions
	{
		public static void SerializeValue(this INetSerializer serializer, ref Color color)
		{
			serializer.SerializeValue(ref color.r);
			serializer.SerializeValue(ref color.g);
			serializer.SerializeValue(ref color.b);
			serializer.SerializeValue(ref color.a);
		}

		public static void SerializeValue(this INetSerializer serializer, ref Quaternion value)
		{
			serializer.SerializeValue(ref value.x);
			serializer.SerializeValue(ref value.y);
			serializer.SerializeValue(ref value.z);
			serializer.SerializeValue(ref value.w);
		}

		public static void SerializeValue(this INetSerializer serializer, ref Vector4 value)
		{
			serializer.SerializeValue(ref value.x);
			serializer.SerializeValue(ref value.y);
			serializer.SerializeValue(ref value.z);
			serializer.SerializeValue(ref value.w);
		}

		public static void SerializeValue(this INetSerializer serializer, ref Vector3 value)
		{
			serializer.SerializeValue(ref value.x);
			serializer.SerializeValue(ref value.y);
			serializer.SerializeValue(ref value.z);
		}

		public static void SerializeValue(this INetSerializer serializer, ref Vector2 value)
		{
			serializer.SerializeValue(ref value.x);
			serializer.SerializeValue(ref value.y);
		}
	}
	public sealed class NetWriter : INetSerializer, IDisposable
	{
		public const int DefaultCapacity = 4096;

		private byte[] _buffer;

		public bool IsReader => false;

		public int Position { get; set; }

		public int Length => Position;

		public ArraySegment<byte> Buffer => new ArraySegment<byte>(_buffer, 0, Length);

		public static NetWriter Create()
		{
			return Create(4096);
		}

		public static NetWriter Create(int? capacity)
		{
			return Create(capacity.GetValueOrDefault(4096));
		}

		public static NetWriter Create(int capacity)
		{
			return new NetWriter
			{
				_buffer = ArrayPool<byte>.Shared.Rent(capacity),
				Position = 0
			};
		}

		public void Write(byte value)
		{
			_buffer[Position++] = value;
		}

		public void Write(bool value)
		{
			Write(value ? ((byte)1) : ((byte)0));
		}

		public void Write(double value)
		{
			BinaryPrimitives.WriteDoubleBigEndian(new Span<byte>(_buffer, Position, 8), value);
			Position += 8;
		}

		public void Write(short value)
		{
			BinaryPrimitives.WriteInt16BigEndian(new Span<byte>(_buffer, Position, 2), value);
			Position += 2;
		}

		public void Write(int value)
		{
			BinaryPrimitives.WriteInt32BigEndian(new Span<byte>(_buffer, Position, 4), value);
			Position += 4;
		}

		public void Write(long value)
		{
			BinaryPrimitives.WriteInt64BigEndian(new Span<byte>(_buffer, Position, 8), value);
			Position += 8;
		}

		public void Write(sbyte value)
		{
			Write(value.ToByte());
		}

		public void Write(float value)
		{
			BinaryPrimitives.WriteSingleBigEndian(new Span<byte>(_buffer, Position, 4), value);
			Position += 4;
		}

		public void Write(ushort value)
		{
			BinaryPrimitives.WriteUInt16BigEndian(new Span<byte>(_buffer, Position, 2), value);
			Position += 2;
		}

		public void Write(uint value)
		{
			BinaryPrimitives.WriteUInt32BigEndian(new Span<byte>(_buffer, Position, 4), value);
			Position += 4;
		}

		public void Write(ulong value)
		{
			BinaryPrimitives.WriteUInt64BigEndian(new Span<byte>(_buffer, Position, 8), value);
			Position += 8;
		}

		public void Write(string value)
		{
			Write(value, Encoding.UTF8);
		}

		public void Write(string value, Encoding encoding)
		{
			if (value == null)
			{
				Write(-1);
				return;
			}
			int byteCount = encoding.GetByteCount(value);
			Write(byteCount);
			encoding.GetBytes(value, 0, value.Length, _buffer, Position);
			Position += byteCount;
		}

		public void Write(byte[] value)
		{
			Write(value.Length);
			System.Buffer.BlockCopy(value, 0, _buffer, Position, value.Length);
			Position += value.Length;
		}

		public void Write(ArraySegment<byte> value)
		{
			Write(value.Count);
			for (int i = 0; i < value.Count; i++)
			{
				_buffer[Position] = value[i];
				Position++;
			}
		}

		public void Write(string[] value)
		{
			Write(value.Length);
			for (int i = 0; i < value.Length; i++)
			{
				Write(value[i]);
			}
		}

		public void Write<TEnum>(TEnum value) where TEnum : struct, Enum
		{
			Write(EnumConverter.ConvertToInt32(value));
		}

		public void Write<TEnum>(TEnum value, Precision precision) where TEnum : struct, Enum
		{
			switch (precision)
			{
			default:
				Write(EnumConverter.ConvertToInt32(value));
				break;
			case Precision.TwoBytes:
				Write(EnumConverter.ConvertToInt16(value));
				break;
			case Precision.OneByte:
				Write(EnumConverter.ConvertToByte(value));
				break;
			}
		}

		public void Write(byte? value)
		{
			Write(value.HasValue);
			if (value.HasValue)
			{
				Write(value.Value);
			}
		}

		public void Write(ushort? value)
		{
			Write(value.HasValue);
			if (value.HasValue)
			{
				Write(value.Value);
			}
		}

		public void Write(int? value)
		{
			Write(value.HasValue);
			if (value.HasValue)
			{
				Write(value.Value);
			}
		}

		public void SerializeValue(ref byte value)
		{
			Write(value);
		}

		public void SerializeValue(ref bool value)
		{
			Write(value);
		}

		public void SerializeValue(ref int value)
		{
			Write(value);
		}

		public void SerializeValue(ref double value)
		{
			Write(value);
		}

		public void SerializeValue(ref short value)
		{
			Write(value);
		}

		public void SerializeValue(ref long value)
		{
			Write(value);
		}

		public void SerializeValue(ref sbyte value)
		{
			Write(value);
		}

		public void SerializeValue(ref float value)
		{
			Write(value);
		}

		public void SerializeValue(ref ushort value)
		{
			Write(value);
		}

		public void SerializeValue(ref uint value)
		{
			Write(value);
		}

		public void SerializeValue(ref ulong value)
		{
			Write(value);
		}

		public void SerializeValue(ref string value)
		{
			Write(value);
		}

		public void SerializeValue(ref byte[] value)
		{
			Write(value);
		}

		public void SerializeValue(ref ArraySegment<byte> value)
		{
			Write(value);
		}

		public void SerializeValue(ref string[] value)
		{
			Write(value);
		}

		public void SerializeValue<TEnum>(ref TEnum value) where TEnum : struct, Enum
		{
			Write(value);
		}

		public void SerializeValue<TEnum>(ref TEnum value, Precision precision) where TEnum : struct, Enum
		{
			Write(value, precision);
		}

		public void SerializeValue(ref byte? value)
		{
			Write(value);
		}

		public void SerializeValue(ref ushort? value)
		{
			Write(value);
		}

		public void SerializeValue(ref int? value)
		{
			Write(value);
		}

		public void Dispose()
		{
			GC.SuppressFinalize(this);
			ArrayPool<byte>.Shared.Return(_buffer);
		}
	}
	public enum Precision
	{
		Full,
		FourBytes,
		TwoBytes,
		OneByte
	}
	public static class SizeExtensions
	{
		public static int GetSize(this string value)
		{
			return value.GetSize(Encoding.UTF8);
		}

		public static int GetSize(this string value, Encoding encoding)
		{
			if (value == null)
			{
				return 4;
			}
			return encoding.GetByteCount(value) + 4;
		}

		public static int GetSize(this Version value)
		{
			return 12;
		}

		public static int GetSize(this string[] array)
		{
			return array.GetSize(Encoding.UTF8);
		}

		public static int GetSize(this string[] array, Encoding encoding)
		{
			int num = 4;
			foreach (string value in array)
			{
				num += value.GetSize(encoding);
			}
			return num;
		}

		public static int GetSize(this List<string> list)
		{
			return list.GetSize(Encoding.UTF8);
		}

		public static int GetSize(this List<string> list, Encoding encoding)
		{
			int num = 4;
			foreach (string item in list)
			{
				num += item.GetSize(encoding);
			}
			return num;
		}

		public static int GetSize(this Dictionary<string, string> dictionary)
		{
			int num = 4;
			foreach (KeyValuePair<string, string> item in dictionary)
			{
				num += item.Key.GetSize() + item.Value.GetSize();
			}
			return num;
		}
	}
}
namespace LabFusion.Network.Proxy
{
	internal enum MessageTypes
	{
		SteamID = 0,
		OnDisconnected = 1,
		OnMessage = 2,
		GetUsername = 3,
		UnreliableBroadcastToClients = 4,
		ReliableBroadcastToClients = 5,
		UnreliableBroadcastToServer = 6,
		ReliableBroadcastToServer = 7,
		OnConnectionDisconnected = 8,
		OnConnectionMessage = 9,
		JoinServer = 10,
		Disconnect = 11,
		Ping = 12,
		StartServer = 13,
		UnreliableSendFromServer = 14,
		ReliableSendFromServer = 15,
		LobbyIDs = 16,
		LobbyMetadata = 17,
		SetLobbyMetadata = 20,
		SteamFriends = 21,
		DisconnectUser = 22
	}
	public class ProxyLobbyManager
	{
		private TaskCompletionSource<ulong[]> _lobbyIdSource;

		private readonly ProxyNetworkLayer _networkLayer;

		private readonly Dictionary<ulong, TaskCompletionSource<LobbyMetadataInfo>> _metadataInfoRequests = new Dictionary<ulong, TaskCompletionSource<LobbyMetadataInfo>>();

		internal ProxyLobbyManager(ProxyNetworkLayer networkLayer)
		{
			_networkLayer = networkLayer;
		}

		internal void HandleLobbyMessage(MessageTypes messageType, NetPacketReader packetReader)
		{
			if (messageType == MessageTypes.LobbyIDs)
			{
				MelonLogger.Msg("Got LobbyIds");
				if (_lobbyIdSource == null)
				{
					MelonLogger.Error("Got extraneous RequestLobbies response?");
					return;
				}
				uint uInt = packetReader.GetUInt();
				ulong[] array = new ulong[uInt];
				for (uint num = 0u; num < uInt; num++)
				{
					array[num] = packetReader.GetULong();
				}
				_lobbyIdSource.SetResult(array);
				_lobbyIdSource = null;
			}
			if (messageType != MessageTypes.LobbyMetadata)
			{
				return;
			}
			ulong uLong = packetReader.GetULong();
			FusionLogger.Log($"Got LobbyMetadata for {uLong}");
			if (!_metadataInfoRequests.ContainsKey(uLong))
			{
				FusionLogger.Error("Got extraneous LobbyMetadata response?");
				return;
			}
			TaskCompletionSource<LobbyMetadataInfo> taskCompletionSource = _metadataInfoRequests[uLong];
			ProxyNetworkLobby proxyNetworkLobby = new ProxyNetworkLobby();
			int @int = packetReader.GetInt();
			for (int i = 0; i < @int; i++)
			{
				string @string = packetReader.GetString();
				string string2 = packetReader.GetString();
				proxyNetworkLobby.CacheMetadata(@string, string2);
			}
			LobbyMetadataInfo result = LobbyMetadataSerializer.ReadInfo(proxyNetworkLobby);
			taskCompletionSource.SetResult(result);
			_metadataInfoRequests.Remove(uLong);
		}

		public Task<ulong[]> RequestLobbyIDs(ProxyLobbyRequestParameters parameters)
		{
			_lobbyIdSource = new TaskCompletionSource<ulong[]>();
			NetDataWriter writer = ProxyNetworkLayer.NewWriter(MessageTypes.LobbyIDs);
			parameters.Put(writer);
			_networkLayer.SendToProxyServer(writer);
			return _lobbyIdSource.Task;
		}

		public Task<LobbyMetadataInfo> RequestLobbyMetadataInfo(ulong lobbyId)
		{
			TaskCompletionSource<LobbyMetadataInfo> taskCompletionSource = new TaskCompletionSource<LobbyMetadataInfo>();
			_metadataInfoRequests.Add(lobbyId, taskCompletionSource);
			NetDataWriter netDataWriter = ProxyNetworkLayer.NewWriter(MessageTypes.LobbyMetadata);
			netDataWriter.Put(lobbyId);
			_networkLayer.SendToProxyServer(netDataWriter);
			return taskCompletionSource.Task;
		}
	}
	public struct ProxyLobbyRequestParameters
	{
		public MatchmakerFilters Filters;

		public int VersionMajor;

		public int VersionMinor;

		public string LobbyCode;

		public readonly void Put(NetDataWriter writer)
		{
			writer.Put(Filters.FilterFull);
			writer.Put(Filters.FilterMismatchingVersions);
			writer.Put(VersionMajor);
			writer.Put(VersionMinor);
			bool flag = LobbyCode != null;
			writer.Put(flag);
			if (flag)
			{
				writer.Put(LobbyCode);
			}
		}
	}
	public sealed class ProxyMatchmaker : IMatchmaker
	{
		[CompilerGenerated]
		private sealed class <FindLobbies>d__6 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ProxyMatchmaker <>4__this;

			public ProxyLobbyRequestParameters parameters;

			public Action<IMatchmaker.MatchmakerCallbackInfo> callback;

			private Task<ulong[]> <task>5__2;

			private float <timeTaken>5__3;

			private List<IMatchmaker.LobbyInfo> <netLobbies>5__4;

			private ulong[] <>7__wrap4;

			private int <>7__wrap5;

			private Task<LobbyMetadataInfo> <metadataTask>5__7;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <FindLobbies>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<task>5__2 = null;
				<netLobbies>5__4 = null;
				<>7__wrap4 = null;
				<metadataTask>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				ProxyMatchmaker proxyMatchmaker = <>4__this;
				IMatchmaker.MatchmakerCallbackInfo matchmakerCallbackInfo;
				IMatchmaker.MatchmakerCallbackInfo obj;
				LobbyMetadataInfo result;
				ProxyNetworkLobby lobby;
				ulong[] result2;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<task>5__2 = proxyMatchmaker._lobbyManager.RequestLobbyIDs(parameters);
					<timeTaken>5__3 = 0f;
					goto IL_008a;
				case 1:
					<>1__state = -1;
					<timeTaken>5__3 += TimeReferences.DeltaTime;
					if (<timeTaken>5__3 >= 20f)
					{
						SendTimeOutNotification();
						return false;
					}
					goto IL_008a;
				case 2:
					{
						<>1__state = -1;
						<timeTaken>5__3 += TimeReferences.DeltaTime;
						if (<timeTaken>5__3 >= 20f)
						{
							SendTimeOutNotification();
							return false;
						}
						goto IL_012d;
					}
					IL_019b:
					if (<>7__wrap5 < <>7__wrap4.Length)
					{
						ulong lobbyId = <>7__wrap4[<>7__wrap5];
						<metadataTask>5__7 = proxyMatchmaker._lobbyManager.RequestLobbyMetadataInfo(lobbyId);
						<timeTaken>5__3 = 0f;
						goto IL_012d;
					}
					<>7__wrap4 = null;
					matchmakerCallbackInfo = default(IMatchmaker.MatchmakerCallbackInfo);
					matchmakerCallbackInfo.Lobbies = <netLobbies>5__4.ToArray();
					obj = matchmakerCallbackInfo;
					callback?.Invoke(obj);
					return false;
					IL_012d:
					if (!<metadataTask>5__7.IsCompleted)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					result = <metadataTask>5__7.Result;
					lobby = new ProxyNetworkLobby
					{
						info = result
					};
					if (result.HasLobbyOpen)
					{
						<netLobbies>5__4.Add(new IMatchmaker.LobbyInfo
						{
							Lobby = lobby,
							Metadata = result
						});
						<metadataTask>5__7 = null;
					}
					<>7__wrap5++;
					goto IL_019b;
					IL_008a:
					if (!<task>5__2.IsCompleted)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<netLobbies>5__4 = new List<IMatchmaker.LobbyInfo>();
					result2 = <task>5__2.Result;
					<>7__wrap4 = result2;
					<>7__wrap5 = 0;
					goto IL_019b;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private ProxyLobbyManager _lobbyManager;

		public ProxyMatchmaker(ProxyLobbyManager lobbyManager)
		{
			_lobbyManager = lobbyManager;
		}

		public void RequestLobbies(Action<IMatchmaker.MatchmakerCallbackInfo> callback)
		{
			RequestLobbies(MatchmakerFilters.Empty, callback);
		}

		public void RequestLobbies(MatchmakerFilters filters, Action<IMatchmaker.MatchmakerCallbackInfo> callback)
		{
			Version version = FusionMod.Version;
			ProxyLobbyRequestParameters proxyLobbyRequestParameters = default(ProxyLobbyRequestParameters);
			proxyLobbyRequestParameters.Filters = filters;
			proxyLobbyRequestParameters.VersionMajor = version.Major;
			proxyLobbyRequestParameters.VersionMinor = version.Minor;
			proxyLobbyRequestParameters.LobbyCode = null;
			ProxyLobbyRequestParameters parameters = proxyLobbyRequestParameters;
			MelonCoroutines.Start(FindLobbies(parameters, callback));
		}

		public void RequestLobbiesByCode(string code, Action<IMatchmaker.MatchmakerCallbackInfo> callback)
		{
			Version version = FusionMod.Version;
			ProxyLobbyRequestParameters proxyLobbyRequestParameters = default(ProxyLobbyRequestParameters);
			proxyLobbyRequestParameters.Filters = MatchmakerFilters.Empty;
			proxyLobbyRequestParameters.VersionMajor = version.Major;
			proxyLobbyRequestParameters.VersionMinor = version.Minor;
			proxyLobbyRequestParameters.LobbyCode = code;
			ProxyLobbyRequestParameters parameters = proxyLobbyRequestParameters;
			MelonCoroutines.Start(FindLobbies(parameters, callback));
		}

		private static void SendTimeOutNotification()
		{
			Notifier.Send(new Notification
			{
				Title = "Timed Out",
				Message = "Requesting Lobby IDs took too long.",
				ShowPopup = true,
				SaveToMenu = false
			});
		}

		[IteratorStateMachine(typeof(<FindLobbies>d__6))]
		private IEnumerator FindLobbies(ProxyLobbyRequestParameters parameters, Action<IMatchmaker.MatchmakerCallbackInfo> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FindLobbies>d__6(0)
			{
				<>4__this = this,
				parameters = parameters,
				callback = callback
			};
		}
	}
	public abstract class ProxyNetworkLayer : NetworkLayer
	{
		[CompilerGenerated]
		private sealed class <DiscoverServer>d__33 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ProxyNetworkLayer <>4__this;

			private int <port>5__2;

			private float <timeElapsed>5__3;

			private NetDataWriter <writer>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DiscoverServer>d__33(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<writer>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				ProxyNetworkLayer proxyNetworkLayer = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_00d7;
				}
				<>1__state = -1;
				<port>5__2 = ClientSettings.ProxyPort.Value;
				if (<port>5__2 < 1024 || <port>5__2 > 65535)
				{
					FusionLogger.Error("Custom port is invalid, using default! (28430)");
					<port>5__2 = 28340;
				}
				<writer>5__4 = new NetDataWriter();
				<writer>5__4.Put("FUSION_SERVER_DISCOVERY");
				goto IL_00e4;
				IL_00e4:
				if (proxyNetworkLayer.serverConnection == null)
				{
					<timeElapsed>5__3 = 0f;
					proxyNetworkLayer.client.SendBroadcast(<writer>5__4, <port>5__2);
					goto IL_00d7;
				}
				return false;
				IL_00d7:
				if (<timeElapsed>5__3 < 5f)
				{
					proxyNetworkLayer.client.PollEvents();
					<timeElapsed>5__3 += TimeReferences.DeltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				goto IL_00e4;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public SteamId SteamId;

		private INetworkLobby _currentLobby;

		private IVoiceManager _voiceManager;

		private IMatchmaker _matchmaker;

		protected bool _isServerActive;

		protected bool _isConnectionActive;

		protected ulong _targetServerId;

		protected string _targetJoinId;

		protected bool _isInitialized;

		private NetManager client;

		private NetPeer serverConnection;

		private ProxyLobbyManager _lobbyManager;

		public static List<ulong> FriendIds = new List<ulong>();

		public abstract uint ApplicationID { get; }

		public static ProxyNetworkLayer Instance { get; private set; }

		public override string Title => "Proxy";

		public override bool IsHost => _isServerActive;

		public override bool IsClient => _isConnectionActive;

		public override INetworkLobby Lobby => _currentLobby;

		public override IVoiceManager VoiceManager => _voiceManager;

		public override IMatchmaker Matchmaker => _matchmaker;

		public string ServerCode { get; private set; }

		public override bool CheckSupported()
		{
			return PlatformHelper.IsAndroid;
		}

		public override bool CheckValidation()
		{
			return true;
		}

		public override void OnInitializeLayer()
		{
			Instance = this;
			_voiceManager = new UnityVoiceManager();
			_voiceManager.Enable();
			HookSteamEvents();
			_lobbyManager = new ProxyLobbyManager(this);
			_matchmaker = new ProxyMatchmaker(_lobbyManager);
		}

		[IteratorStateMachine(typeof(<DiscoverServer>d__33))]
		public IEnumerator DiscoverServer()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DiscoverServer>d__33(0)
			{
				<>4__this = this
			};
		}

		public void EvaluateMessage(NetPeer fromPeer, NetPacketReader dataReader, byte channel, DeliveryMethod deliveryMethod)
		{
			ulong num = dataReader.GetByte();
			if (num <= 21)
			{
				switch (num)
				{
				case 12uL:
				{
					double @double = dataReader.GetDouble();
					double totalMilliseconds = DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalMilliseconds;
					FusionLogger.Log("Server -> Client = " + (totalMilliseconds - @double) + " ms.");
					NetDataWriter netDataWriter = NewWriter(MessageTypes.Ping);
					netDataWriter.Put(totalMilliseconds);
					SendToProxyServer(netDataWriter);
					break;
				}
				case 0uL:
				{
					SteamId = new SteamId
					{
						Value = dataReader.GetULong()
					};
					if (SteamId.Value == 0L)
					{
						FusionLogger.Error("Steamworks failed to initialize!");
						break;
					}
					PlayerIDManager.SetLongID(SteamId.Value);
					NetDataWriter netDataWriter2 = NewWriter(MessageTypes.GetUsername);
					netDataWriter2.Put(SteamId.Value);
					SendToProxyServer(netDataWriter2);
					FusionLogger.Log($"Steamworks initialized with SteamID {SteamId}!");
					_isInitialized = true;
					break;
				}
				case 3uL:
					LocalPlayer.Username = dataReader.GetString();
					break;
				case 1uL:
				{
					ulong uLong4 = dataReader.GetULong();
					if (PlayerIDManager.HasPlayerID(uLong4))
					{
						InternalServerHelpers.OnPlayerLeft(uLong4);
						ConnectionSender.SendDisconnect(uLong4);
					}
					break;
				}
				case 2uL:
				{
					byte[] bytesWithLength2 = dataReader.GetBytesWithLength();
					ulong uLong3 = dataReader.GetULong();
					ProxySocketHandler.OnSocketMessageReceived(bytesWithLength2, isServerHandled: true, uLong3);
					break;
				}
				case 8uL:
					NetworkHelper.Disconnect();
					break;
				case 9uL:
				{
					byte[] bytesWithLength = dataReader.GetBytesWithLength();
					ulong uLong2 = dataReader.GetULong();
					ProxySocketHandler.OnSocketMessageReceived(bytesWithLength, isServerHandled: false, uLong2);
					break;
				}
				case 10uL:
				{
					ulong uLong = dataReader.GetULong();
					JoinServer(new SteamId
					{
						Value = uLong
					});
					break;
				}
				case 13uL:
					_isServerActive = true;
					_isConnectionActive = true;
					InternalServerHelpers.OnStartServer();
					RefreshServerCode();
					break;
				case 16uL:
				case 17uL:
					_lobbyManager.HandleLobbyMessage((MessageTypes)num, dataReader);
					break;
				case 21uL:
					FriendIds = dataReader.GetULongArray().ToList();
					break;
				}
			}
			dataReader.Recycle();
		}

		public override void OnDeinitializeLayer()
		{
			Disconnect();
			UnHookSteamEvents();
			_voiceManager.Disable();
			_voiceManager = null;
		}

		public override void LogIn()
		{
			if (client != null)
			{
				client.Stop();
				client = null;
				serverConnection = null;
			}
			EventBasedNetListener listener = new EventBasedNetListener();
			client = new NetManager(listener)
			{
				UnconnectedMessagesEnabled = true,
				BroadcastReceiveEnabled = true,
				DisconnectOnUnreachable = true,
				DisconnectTimeout = 10000,
				PingInterval = 5000
			};
			listener.NetworkReceiveEvent += EvaluateMessage;
			listener.PeerConnectedEvent += delegate(NetPeer peer)
			{
				InvokeLoggedInEvent();
				serverConnection = peer;
				NetDataWriter netDataWriter = NewWriter(MessageTypes.SteamID);
				listener.PeerDisconnectedEvent += delegate
				{
					FusionLogger.Error("Proxy has disconnected, logging out!");
					serverConnection = null;
					InvokeLoggedOutEvent();
				};
				netDataWriter.Put(ApplicationID);
				SendToProxyServer(netDataWriter);
			};
			listener.NetworkReceiveUnconnectedEvent += delegate(IPEndPoint endPoint, NetPacketReader reader, UnconnectedMessageType messageType)
			{
				if (reader.TryGetString(out var result) && result == "YOU_FOUND_ME")
				{
					FusionLogger.Log("Found the proxy server!");
					client.Connect(endPoint, "ProxyConnection");
				}
				reader.Recycle();
			};
			client.Start();
			FusionLogger.Log("Beginning proxy discovery...");
			MelonCoroutines.Start(DiscoverServer());
		}

		public override void LogOut()
		{
			client.Stop();
			client = null;
			serverConnection = null;
			InvokeLoggedOutEvent();
		}

		public override void OnUpdateLayer()
		{
			client.PollEvents();
		}

		internal static NetDataWriter NewWriter(MessageTypes type)
		{
			NetDataWriter netDataWriter = new NetDataWriter();
			netDataWriter.Put((byte)type);
			return netDataWriter;
		}

		public void SendToProxyServer(NetDataWriter writer)
		{
			if (serverConnection == null)
			{
				FusionLogger.Warn("Attempting to send data to a null server peer! Is the proxy active?");
				Notifier.Send(new Notification
				{
					SaveToMenu = false,
					ShowPopup = true,
					PopupLength = 4f,
					Title = "Connection Failed",
					Message = "Failed to send data to the proxy, is FusionHelper running on your computer?",
					Type = NotificationType.ERROR
				});
			}
			else
			{
				serverConnection.Send(writer, DeliveryMethod.ReliableOrdered);
			}
		}

		internal void SendToProxyServer(MessageTypes type)
		{
			if (serverConnection == null)
			{
				FusionLogger.Warn("Attempting to send data to a null server peer! Is the proxy active?");
				return;
			}
			NetDataWriter dataWriter = NewWriter(type);
			serverConnection.Send(dataWriter, DeliveryMethod.ReliableOrdered);
		}

		public override bool IsFriend(ulong userId)
		{
			if (FriendIds.Contains(userId))
			{
				return true;
			}
			return false;
		}

		public override void BroadcastMessage(NetworkChannel channel, NetMessage message)
		{
			if (IsHost)
			{
				ProxySocketHandler.BroadcastToClients(channel, message);
			}
			else
			{
				ProxySocketHandler.BroadcastToServer(channel, message);
			}
		}

		public override void SendToServer(NetworkChannel channel, NetMessage message)
		{
			ProxySocketHandler.BroadcastToServer(channel, message);
		}

		public override void SendFromServer(byte userId, NetworkChannel channel, NetMessage message)
		{
			PlayerID playerID = PlayerIDManager.GetPlayerID(userId);
			if (playerID != null)
			{
				SendFromServer(playerID.PlatformID, channel, message);
			}
		}

		public override void SendFromServer(ulong userId, NetworkChannel channel, NetMessage message)
		{
			if (IsHost)
			{
				NetDataWriter netDataWriter = NewWriter((channel == NetworkChannel.Unreliable) ? MessageTypes.UnreliableSendFromServer : MessageTypes.ReliableSendFromServer);
				netDataWriter.Put(userId);
				byte[] data = message.ToByteArray();
				netDataWriter.PutBytesWithLength(data);
				SendToProxyServer(netDataWriter);
			}
		}

		public override void StartServer()
		{
			SendToProxyServer(MessageTypes.StartServer);
		}

		public void JoinServer(SteamId serverId)
		{
			if (_isConnectionActive || _isServerActive)
			{
				Disconnect();
			}
			NetDataWriter netDataWriter = NewWriter(MessageTypes.JoinServer);
			netDataWriter.Put((ulong)serverId);
			SendToProxyServer(netDataWriter);
			_isServerActive = false;
			_isConnectionActive = true;
			ConnectionSender.SendConnectionRequest();
		}

		public override void Disconnect(string reason = "")
		{
			if (_isServerActive || _isConnectionActive)
			{
				try
				{
					SendToProxyServer(MessageTypes.Disconnect);
				}
				catch
				{
					FusionLogger.Log("Error closing socket server / connection manager");
				}
				_isServerActive = false;
				_isConnectionActive = false;
				InternalServerHelpers.OnDisconnect(reason);
			}
		}

		public override void DisconnectUser(ulong platformID)
		{
			if (_isServerActive)
			{
				NetDataWriter netDataWriter = NewWriter(MessageTypes.DisconnectUser);
				netDataWriter.Put(platformID);
				SendToProxyServer(netDataWriter);
			}
		}

		public override string GetServerCode()
		{
			return ServerCode;
		}

		public override void RefreshServerCode()
		{
			ServerCode = RandomCodeGenerator.GetString(8);
			LobbyInfoManager.PushLobbyUpdate();
		}

		public override void JoinServerByCode(string code)
		{
			if (Matchmaker == null)
			{
				return;
			}
			Matchmaker.RequestLobbiesByCode(code, delegate(IMatchmaker.MatchmakerCallbackInfo info)
			{
				if (info.Lobbies.Length != 0)
				{
					JoinServer(info.Lobbies[0].Metadata.LobbyInfo.LobbyID);
				}
			});
		}

		private void HookSteamEvents()
		{
			MultiplayerHooking.OnPlayerJoined += OnPlayerJoin;
			MultiplayerHooking.OnPlayerLeft += OnPlayerLeave;
			MultiplayerHooking.OnDisconnected += OnDisconnect;
			LobbyInfoManager.OnLobbyInfoChanged += OnUpdateLobby;
			_currentLobby = new ProxyNetworkLobby();
		}

		private void OnPlayerJoin(PlayerID id)
		{
			if (!id.IsMe)
			{
				_voiceManager.GetSpeaker(id);
			}
			OnUpdateLobby();
		}

		private void OnPlayerLeave(PlayerID id)
		{
			_voiceManager.RemoveSpeaker(id);
		}

		private void OnDisconnect()
		{
			_voiceManager.ClearManager();
		}

		private void UnHookSteamEvents()
		{
			MultiplayerHooking.OnPlayerJoined -= OnPlayerJoin;
			MultiplayerHooking.OnPlayerLeft -= OnPlayerLeave;
			MultiplayerHooking.OnDisconnected -= OnDisconnect;
			LobbyInfoManager.OnLobbyInfoChanged -= OnUpdateLobby;
		}

		public void OnUpdateLobby()
		{
			if (Lobby != null)
			{
				LobbyMetadataSerializer.WriteInfo(Lobby);
				NetDataWriter writer = NewWriter(MessageTypes.SteamFriends);
				SendToProxyServer(writer);
			}
		}
	}
	public class ProxyNetworkLobby : NetworkLobby
	{
		public LobbyMetadataInfo info;

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

		public void CacheMetadata(string key, string value)
		{
			_cachedMetadata[key] = value;
		}

		public override string GetMetadata(string key)
		{
			return _cachedMetadata[key];
		}

		public override void SetMetadata(string key, string value)
		{
			_cachedMetadata[key] = value;
			SaveKey(key);
			NetDataWriter netDataWriter = ProxyNetworkLayer.NewWriter(MessageTypes.SetLobbyMetadata);
			netDataWriter.Put(key);
			netDataWriter.Put(value);
			ProxyNetworkLayer.Instance.SendToProxyServer(netDataWriter);
		}

		public override bool TryGetMetadata(string key, out string value)
		{
			if (_cachedMetadata.TryGetValue(key, out value))
			{
				return !string.IsNullOrWhiteSpace(value);
			}
			return false;
		}

		public override Action CreateJoinDelegate(ulong lobbyId)
		{
			NetworkLayer layer = NetworkLayerManager.Layer;
			ProxyNetworkLayer proxyLayer = layer as ProxyNetworkLayer;
			if (proxyLayer != null)
			{
				return delegate
				{
					proxyLayer.JoinServer(lobbyId);
				};
			}
			return null;
		}
	}
	public static class ProxySocketHandler
	{
		public static void BroadcastToClients(NetworkChannel channel, NetMessage message)
		{
			NetDataWriter netDataWriter = ProxyNetworkLayer.NewWriter((channel == NetworkChannel.Reliable) ? MessageTypes.ReliableBroadcastToClients : MessageTypes.UnreliableBroadcastToClients);
			byte[] data = message.ToByteArray();
			netDataWriter.PutBytesWithLength(data);
			ProxyNetworkLayer.Instance.SendToProxyServer(netDataWriter);
		}

		public static void BroadcastToServer(NetworkChannel channel, NetMessage message)
		{
			try
			{
				NetDataWriter netDataWriter = ProxyNetworkLayer.NewWriter((channel == NetworkChannel.Reliable) ? MessageTypes.ReliableBroadcastToServer : MessageTypes.UnreliableBroadcastToServer);
				byte[] data = message.ToByteArray();
				netDataWriter.PutBytesWithLength(data);
				ProxyNetworkLayer.Instance.SendToProxyServer(netDataWriter);
			}
			catch (Exception ex)
			{
				FusionLogger.Error("Failed sending message to socket server with reason: " + ex.Message + "\nTrace:" + ex.StackTrace);
			}
		}

		public static void OnSocketMessageReceived(byte[] message, bool isServerHandled = false, ulong? platformID = null)
		{
			try
			{
				ReadableMessage message2 = default(ReadableMessage);
				message2.Buffer = new ReadOnlySpan<byte>(message);
				message2.IsServerHandled = isServerHandled;
				message2.PlatformID = platformID;
				NativeMessageHandler.ReadMessage(message2);
			}
			catch (Exception ex)
			{
				FusionLogger.Error("Failed reading message from socket server with reason: " + ex.Message + "\nTrace:" + ex.StackTrace);
			}
		}
	}
	public sealed class ProxySteamVRNetworkLayer : ProxyNetworkLayer
	{
		public override uint ApplicationID => 250820u;

		public override string Title => "Proxy SteamVR";

		public override string Platform => "Steam";
	}
}
namespace LabFusion.MonoBehaviours
{
	[RegisterTypeInIl2Cpp]
	public class AntiHasher : MonoBehaviour
	{
		public AntiHasher(IntPtr intPtr)
			: base(intPtr)
		{
		}
	}
	[RegisterTypeInIl2Cpp]
	public class CollisionSyncer : MonoBehaviour
	{
		public CollisionSyncer(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void OnCollisionEnter(Collision collision)
		{
			if (NetworkInfo.HasServer)
			{
				Rigidbody rigidbody = collision.rigidbody;
				if (Object.op_Implicit((Object)(object)rigidbody))
				{
					ImpactUtilities.OnHitRigidbody(rigidbody);
				}
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public class DestroyOnDisconnect : MonoBehaviour
	{
		public DestroyOnDisconnect(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			MultiplayerHooking.OnDisconnected += OnDisconnect;
		}

		private void OnDestroy()
		{
			MultiplayerHooking.OnDisconnected -= OnDisconnect;
		}

		private void OnDisconnect()
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class DestroySensor : MonoBehaviour
	{
		private Action _onDestroyed;

		private bool _isDestroyed;

		public DestroySensor(IntPtr intPtr)
			: base(intPtr)
		{
		}

		[HideFromIl2Cpp]
		public void Hook(Action hook)
		{
			if (_isDestroyed)
			{
				hook();
			}
			else
			{
				_onDestroyed = (Action)Delegate.Combine(_onDestroyed, hook);
			}
		}

		private void OnDestroy()
		{
			_onDestroyed?.Invoke();
			_onDestroyed = null;
			_isDestroyed = true;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class MirrorIdentifier : MonoBehaviour
	{
		public byte id;

		public MirrorIdentifier(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void Awake()
		{
			MultiplayerHooking.OnDisconnected += OnDisconnect;
		}

		public void OnDestroy()
		{
			MultiplayerHooking.OnDisconnected -= OnDisconnect;
		}

		private void OnDisconnect()
		{
			Object.Destroy((Object)(object)this);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class NotifyOnEnable : MonoBehaviour
	{
		private Action _hook;

		private bool _isEnabled;

		public NotifyOnEnable(IntPtr intPtr)
			: base(intPtr)
		{
		}

		[HideFromIl2Cpp]
		public void Hook(Action hook)
		{
			if (_isEnabled)
			{
				hook();
			}
			else
			{
				_hook = (Action)Delegate.Combine(_hook, hook);
			}
		}

		public void OnEnable()
		{
			_isEnabled = true;
			_hook?.Invoke();
			_hook = null;
		}

		public void OnDisable()
		{
			_isEnabled = false;
		}

		public void OnDestroy()
		{
			_hook = null;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class TimedDespawner : MonoBehaviour
	{
		public delegate bool DespawnCheck();

		public const float TotalDespawnTime = 10f;

		private Poolee _poolee;

		private float _elapsedTime;

		public Poolee Poolee
		{
			get
			{
				return _poolee;
			}
			set
			{
				_poolee = value;
			}
		}

		[HideFromIl2Cpp]
		public event DespawnCheck OnDespawnCheck;

		public TimedDespawner(IntPtr intPtr)
			: base(intPtr)
		{
		}

		[HideFromIl2Cpp]
		public void RefreshTimer()
		{
			_elapsedTime = 0f;
		}

		private void OnEnable()
		{
			RefreshTimer();
		}

		private void OnDisable()
		{
			RefreshTimer();
		}

		private void LateUpdate()
		{
			_elapsedTime += TimeReferences.DeltaTime;
			if (_elapsedTime >= 10f)
			{
				bool? flag = this.OnDespawnCheck?.Invoke();
				if (flag.HasValue && !flag.Value)
				{
					RefreshTimer();
				}
				else
				{
					_poolee.Despawn();
				}
			}
		}
	}
}
namespace LabFusion.Menu
{
	public static class ElementIconHelper
	{
		public const float WideAspectRatio = 1.7777778f;

		public static void SetProfileIcon(RawImage rawImage, AspectRatioFitter aspectRatioFitter, string avatarTitle, int modID = -1)
		{
			aspectRatioFitter.aspectRatio = 1f;
			Texture avatarIcon = MenuResources.GetAvatarIcon(avatarTitle);
			if ((Object)(object)avatarIcon == (Object)null)
			{
				avatarIcon = MenuResources.GetAvatarIcon("Mods");
			}
			rawImage.texture = avatarIcon;
			if (modID == -1)
			{
				return;
			}
			ModIOThumbnailDownloader.GetThumbnail(modID, delegate(Texture texture)
			{
				if (!((Object)(object)rawImage == (Object)null))
				{
					rawImage.texture = texture;
					aspectRatioFitter.aspectRatio = 1.7777778f;
				}
			});
		}

		public static void SetProfileIcon(PlayerElement element, string avatarTitle, int modID = -1)
		{
			SetProfileIcon(element.PlayerIcon, element.PlayerIconFitter, avatarTitle, modID);
		}

		public static void SetProfileResultIcon(PlayerResultElement element, string avatarTitle, int modID = -1)
		{
			SetProfileIcon(element.PlayerIcon, element.PlayerIconFitter, avatarTitle, modID);
		}

		public static void SetLevelIcon(RawImage rawImage, string levelTitle, int modID = -1)
		{
			Texture levelIcon = MenuResources.GetLevelIcon(levelTitle);
			if ((Object)(object)levelIcon == (Object)null)
			{
				levelIcon = MenuResources.GetLevelIcon("Mods");
			}
			rawImage.texture = levelIcon;
			if (modID == -1)
			{
				return;
			}
			ModIOThumbnailDownloader.GetThumbnail(modID, delegate(Texture texture)
			{
				if (!((Object)(object)rawImage == (Object)null))
				{
					rawImage.texture = texture;
				}
			});
		}

		public static void SetLevelIcon(LobbyElement element, string levelTitle, int modID = -1)
		{
			SetLevelIcon(element.LevelIcon, levelTitle, modID);
		}

		public static void SetLevelResultIcon(LobbyResultElement element, string levelTitle, int modID = -1)
		{
			SetLevelIcon(element.LevelIcon, levelTitle, modID);
		}

		public static void SetGamemodeIcon(LobbyElement element, string gamemodeTitle)
		{
			Texture gamemodeIcon = MenuResources.GetGamemodeIcon("Sandbox");
			if (!string.IsNullOrWhiteSpace(gamemodeTitle))
			{
				gamemodeIcon = MenuResources.GetGamemodeIcon(gamemodeTitle);
			}
			if ((Object)(object)gamemodeIcon == (Object)null)
			{
				gamemodeIcon = MenuResources.GetGamemodeIcon("Mods");
			}
			element.GamemodeIcon.texture = gamemodeIcon;
		}
	}
	public static class MenuMatchmaking
	{
		private static bool _isSearchingLobbies;

		public static MenuPage MatchmakingPage { get; private set; }

		public static GameObject BrowserFiltersRoot { get; private set; }

		public static PageElement BrowserFiltersElement { get; private set; }

		public static PageElement SandboxFiltersPageElement { get; private set; }

		public static GroupElement SandboxFiltersGroupElement { get; private set; }

		public static FunctionElement GamemodeOptionElement { get; private set; }

		public static FunctionElement SandboxOptionElement { get; private set; }

		public static FunctionElement BrowseOptionElement { get; private set; }

		public static FunctionElement CodeOptionElement { get; private set; }

		public static StringElement CodeElement { get; private set; }

		public static MenuPage BrowserPage { get; private set; }

		public static PageElement LobbyBrowserElement { get; private set; }

		public static PageElement SearchResultsElement { get; private set; }

		public static StringElement SearchBarElement { get; private set; }

		public static FunctionElement RefreshElement { get; private set; }

		public static LabelElement NoServersFoundElement { get; private set; }

		public static LobbyElement LobbyPanel { get; private set; }

		public static void PopulateMatchmaking(GameObject matchmakingPage)
		{
			MatchmakingPage = matchmakingPage.GetComponent<MenuPage>();
			MenuPage matchmakingPage2 = MatchmakingPage;
			matchmakingPage2.OnShown = (Action)Delegate.Combine(matchmakingPage2.OnShown, new Action(OnMatchmakingPageShown));
			PopulateOptions(matchmakingPage.transform.Find("page_Options"));
			MenuMatchmakingSandbox.PopulateSandbox(matchmakingPage.transform.Find("page_Sandbox"));
			MenuMatchmakingGamemodes.PopulateGamemodes(matchmakingPage.transform.Find("page_Gamemodes"));
			PopulateCode(matchmakingPage.transform.Find("page_Code"));
			PopulateBrowser(matchmakingPage.transform.Find("page_Browser"));
		}

		private static void OnMatchmakingPageShown()
		{
			bool active = NetworkLayerManager.Layer.Matchmaker != null;
			((Component)GamemodeOptionElement).gameObject.SetActive(active);
			((Component)SandboxOptionElement).gameObject.SetActive(active);
			((Component)BrowseOptionElement).gameObject.SetActive(active);
		}

		private static void PopulateOptions(Transform optionsTransform)
		{
			Transform obj = optionsTransform.Find("grid_Options");
			GamemodeOptionElement = ((Component)obj.Find("button_Gamemode")).GetComponent<FunctionElement>();
			((Component)((Component)GamemodeOptionElement).transform.Find("label_Title")).GetComponent<LabelElement>().Title = "Gamemode";
			GamemodeOptionElement.Do(delegate
			{
				MatchmakingPage.SelectSubPage(1);
			});
			SandboxOptionElement = ((Component)obj.Find("button_Sandbox")).GetComponent<FunctionElement>();
			SandboxOptionElement.Do(delegate
			{
				MatchmakingPage.SelectSubPage(2);
				RefreshBrowser();
			});
			((Component)((Component)SandboxOptionElement).transform.Find("label_Title")).GetComponent<LabelElement>().Title = "Sandbox";
			BrowseOptionElement = ((Component)obj.Find("button_Browse")).GetComponent<FunctionElement>();
			BrowseOptionElement.Do(delegate
			{
				MatchmakingPage.SelectSubPage(4);
				RefreshBrowser();
			});
			((Component)((Component)BrowseOptionElement).transform.Find("label_Title")).GetComponent<LabelElement>().Title = "Browse";
			CodeOptionElement = ((Component)obj.Find("button_Code")).GetComponent<FunctionElement>();
			CodeOptionElement.Do(delegate
			{
				MatchmakingPage.SelectSubPage(3);
			});
			((Component)((Component)CodeOptionElement).transform.Find("label_Title")).GetComponent<LabelElement>().Title = "Enter Code";
		}

		private static void PopulateCode(Transform codeTransform)
		{
			Transform obj = codeTransform.Find("grid_Buttons");
			CodeElement = ((Component)obj.Find("button_Code")).GetComponent<StringElement>();
			CodeElement.Title = "Code";
			CodeElement.EmptyFormat = "Enter {0}";
			StringElement codeElement = CodeElement;
			codeElement.OnKeyboardToggled = (Action<bool>)Delegate.Combine(codeElement.OnKeyboardToggled, (Action<bool>)delegate(bool v)
			{
				if (v)
				{
					Keyboard keyboard = MenuCreator.MenuPopups.Keyboard;
					keyboard.TemporaryUppercase = false;
					keyboard.Uppercase = true;
				}
			});
			((Component)obj.Find("button_Join")).GetComponent<FunctionElement>().WithTitle("Join").Do(delegate
			{
				string value = CodeElement.Value;
				if (!string.IsNullOrWhiteSpace(value))
				{
					NetworkHelper.JoinServerByCode(value);
				}
			});
		}

		private static void PopulateBrowser(Transform browserTransform)
		{
			BrowserPage = ((Component)browserTransform).GetComponent<MenuPage>();
			Transform obj = browserTransform.Find("page_Search");
			Transform obj2 = obj.Find("group_Filters");
			BrowserFiltersRoot = ((Component)obj2).gameObject;
			BrowserFiltersElement = ((Component)obj2.Find("scrollRect_Filters/Viewport/Content")).GetComponent<PageElement>();
			SandboxFiltersPageElement = BrowserFiltersElement.AddPage();
			SandboxFiltersGroupElement = SandboxFiltersPageElement.AddElement<GroupElement>("Filters");
			AddFilters();
			Transform obj3 = obj.Find("group_Search");
			LobbyBrowserElement = ((Component)obj3.Find("scrollRect_LobbyBrowser/Viewport/Content")).GetComponent<PageElement>();
			SearchResultsElement = LobbyBrowserElement.AddElement<PageElement>("Search Results");
			SearchBarElement = ((Component)obj3.Find("button_SearchBar")).GetComponent<StringElement>();
			SearchBarElement.EmptyFormat = "Enter server or level name";
			SearchBarElement.TextFormat = "{1}";
			StringElement searchBarElement = SearchBarElement;
			searchBarElement.OnSubmitted = (Action)Delegate.Combine(searchBarElement.OnSubmitted, new Action(RefreshBrowser));
			NoServersFoundElement = ((Component)obj3.Find("label_NoServersFound")).GetComponent<LabelElement>();
			NoServersFoundElement.Title = "No servers found :/";
			RefreshElement = ((Component)obj3.Find("button_Refresh")).GetComponent<FunctionElement>();
			RefreshElement.Do(RefreshBrowser);
			LobbyPanel = ((Component)browserTransform.Find("page_Lobby/panel_Lobby")).GetComponent<LobbyElement>();
			LobbyPanel.GetElements();
			LobbyPanel.Interactable = false;
		}

		public static void AddFilters()
		{
			foreach (ILobbyFilter lobbyFilter in LobbyFilterManager.LobbyFilters)
			{
				AddFilter(SandboxFiltersGroupElement, lobbyFilter);
			}
		}

		private static void AddFilter(GroupElement element, ILobbyFilter filter)
		{
			BoolElement boolElement = element.AddElement<BoolElement>(filter.GetTitle());
			boolElement.Value = filter.IsActive();
			boolElement.OnValueChanged = (Action<bool>)Delegate.Combine(boolElement.OnValueChanged, (Action<bool>)delegate(bool v)
			{
				filter.SetActive(v);
				RefreshBrowser();
			});
		}

		public static void RefreshBrowser()
		{
			if (!_isSearchingLobbies)
			{
				SearchResultsElement.RemoveElements<LobbyResultElement>();
				((Component)NoServersFoundElement).gameObject.SetActive(false);
				_isSearchingLobbies = true;
				NetworkLayerManager.Layer.Matchmaker?.RequestLobbies(LobbyFilterManager.CreateMatchmakerFilters(), OnLobbiesRequested);
			}
		}

		private static bool CheckLobbyVisibility(IMatchmaker.LobbyInfo info)
		{
			return info.Metadata.LobbyInfo.Privacy switch
			{
				ServerPrivacy.PUBLIC => true, 
				ServerPrivacy.FRIENDS_ONLY => NetworkLayerManager.Layer.IsFriend(info.Metadata.LobbyInfo.LobbyID), 
				_ => false, 
			};
		}

		private static bool CheckLobbySearch(IMatchmaker.LobbyInfo info, string query)
		{
			LobbyMetadataInfo metadata = info.Metadata;
			string text = metadata.LobbyInfo.LevelTitle.ToLower();
			string text2 = metadata.LobbyInfo.LobbyName.ToLower();
			string text3 = metadata.LobbyInfo.LobbyHostName.ToLower();
			if (text.Contains(query))
			{
				return true;
			}
			if (!string.IsNullOrWhiteSpace(text2) && text2.Contains(query))
			{
				return true;
			}
			if (text3.Contains(query))
			{
				return true;
			}
			return false;
		}

		public static IEnumerable<IMatchmaker.LobbyInfo> ValidateLobbies(IEnumerable<IMatchmaker.LobbyInfo> lobbies)
		{
			return lobbies.Where(CheckLobbyVisibility);
		}

		private static IEnumerable<IMatchmaker.LobbyInfo> SortLobbies(IEnumerable<IMatchmaker.LobbyInfo> lobbies)
		{
			return (from l in lobbies
				orderby l.Metadata.LobbyInfo.LobbyHostName
				orderby l.Metadata.LobbyInfo.PlayerCount descending
				orderby l.Metadata.LobbyInfo.LobbyVersion descending
				orderby l.Metadata.LobbyInfo.LevelTitle
				select l).Where(CheckLobbyVisibility);
		}

		public static bool LoadLobbiesIntoBrowser(IEnumerable<IMatchmaker.LobbyInfo> lobbies)
		{
			MatchmakingPage.SelectSubPage(4);
			SearchResultsElement.RemoveElements<LobbyResultElement>();
			IEnumerable<IMatchmaker.LobbyInfo> enumerable = SortLobbies(lobbies);
			foreach (IMatchmaker.LobbyInfo item in enumerable)
			{
				ApplyLobbyToResult(SearchResultsElement.AddElement<LobbyResultElement>("Lobby Result"), item);
			}
			bool flag = enumerable.Any();
			((Component)NoServersFoundElement).gameObject.SetActive(!flag);
			return flag;
		}

		private static void OnLobbiesRequested(IMatchmaker.MatchmakerCallbackInfo info)
		{
			_isSearchingLobbies = false;
			IEnumerable<IMatchmaker.LobbyInfo> enumerable = from l in SortLobbies(info.Lobbies)
				where LobbyFilterManager.CheckOptionalFilters(l.Lobby, l.Metadata)
				where LobbyFilterManager.CheckPersistentFilters(l.Lobby, l.Metadata)
				select l;
			((Component)SearchBarElement).gameObject.SetActive(true);
			((Component)RefreshElement).gameObject.SetActive(true);
			BrowserFiltersRoot.SetActive(true);
			string searchQuery = SearchBarElement.Value;
			if (!string.IsNullOrWhiteSpace(searchQuery))
			{
				enumerable = enumerable.Where((IMatchmaker.LobbyInfo l) => CheckLobbySearch(l, searchQuery));
			}
			foreach (IMatchmaker.LobbyInfo item in enumerable)
			{
				ApplyLobbyToResult(SearchResultsElement.AddElement<LobbyResultElement>("Lobby Result"), item);
			}
			bool flag = enumerable.Any();
			((Component)NoServersFoundElement).gameObject.SetActive(!flag);
		}

		private static void OnShowLobby(IMatchmaker.LobbyInfo info)
		{
			MatchmakingPage.SelectSubPage(4);
			BrowserPage.SelectSubPage(1);
			ApplyServerMetadataToLobby(LobbyPanel, info.Lobby, info.Metadata);
		}

		private static void OnShowPlayer(PlayerInfo info)
		{
			MatchmakingPage.SelectSubPage(4);
			BrowserPage.SelectSubPage(1);
			LobbyPanel.LobbyPage.SelectSubPage(2);
			ApplyPlayerToElement(LobbyPanel.ProfileElement, info);
		}

		private static void ApplyLobbyToResult(LobbyResultElement element, IMatchmaker.LobbyInfo info)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			element.GetReferences();
			LobbyMetadataInfo metadata = info.Metadata;
			element.OnPressed = delegate
			{
				OnShowLobby(info);
			};
			Color color = Color.white;
			Color color2 = Color.white;
			Color color3 = Color.white;
			if (!metadata.ClientHasLevel)
			{
				color = Color.yellow;
			}
			if (NetworkVerification.CompareVersion(metadata.LobbyInfo.LobbyVersion, FusionMod.Version) != VersionResult.Ok)
			{
				color2 = Color.red;
			}
			if (metadata.LobbyInfo.PlayerCount >= metadata.LobbyInfo.MaxPlayers)
			{
				color3 = Color.red;
			}
			element.LevelNameText.text = metadata.LobbyInfo.LevelTitle;
			((Graphic)element.LevelNameText).color = color;
			element.ServerNameText.text = TextFilter.FilterCommon(ParseServerName(metadata.LobbyInfo.LobbyName, metadata.LobbyInfo.LobbyHostName));
			element.HostNameText.text = TextFilter.FilterCommonAndRichText(metadata.LobbyInfo.LobbyHostName);
			element.PlayerCountText.text = string.Format($"{metadata.LobbyInfo.PlayerCount}/{metadata.LobbyInfo.MaxPlayers} Players");
			((Graphic)element.PlayerCountText).color = color3;
			element.VersionText.text = string.Format($"v{metadata.LobbyInfo.LobbyVersion}");
			((Graphic)element.VersionText).color = color2;
			ElementIconHelper.SetLevelResultIcon(element, metadata.LobbyInfo.LevelTitle, metadata.LobbyInfo.LevelModID);
			Texture gamemodeIcon = MenuResources.GetGamemodeIcon("Sandbox");
			if (!string.IsNullOrWhiteSpace(metadata.LobbyInfo.GamemodeTitle))
			{
				gamemodeIcon = MenuResources.GetGamemodeIcon(metadata.LobbyInfo.GamemodeTitle);
			}
			if ((Object)(object)gamemodeIcon == (Object)null)
			{
				gamemodeIcon = MenuResources.GetGamemodeIcon("Mods");
			}
			element.GamemodeIcon.texture = gamemodeIcon;
		}

		private static string ParseServerName(string serverName, string hostName)
		{
			if (string.IsNullOrWhiteSpace(serverName))
			{
				serverName = hostName.RemoveRichText() + "'s Server";
			}
			return serverName;
		}

		private static void ApplyServerMetadataToLobby(LobbyElement element, INetworkLobby lobby, LobbyMetadataInfo info)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			Color color = Color.white;
			Color color2 = Color.white;
			Color color3 = Color.white;
			Color color4 = Color.white;
			if (!info.ClientHasLevel)
			{
				color = Color.yellow;
				color2 = Color.yellow;
			}
			if (NetworkVerification.CompareVersion(info.LobbyInfo.LobbyVersion, FusionMod.Version) != VersionResult.Ok)
			{
				color = Color.red;
				color3 = Color.red;
			}
			if (info.LobbyInfo.PlayerCount >= info.LobbyInfo.MaxPlayers)
			{
				color = Color.red;
				color4 = Color.red;
			}
			element.ServerActionElement.Cleared().WithTitle("Join").Do(info.CreateJoinDelegate(lobby))
				.WithColor(color);
			element.LevelNameElement.WithTitle(info.LobbyInfo.LevelTitle).WithColor(color2);
			element.ServerVersionElement.WithTitle($"v{info.LobbyInfo.LobbyVersion}").WithColor(color3);
			element.PlayersElement.Cleared().WithTitle("Players").WithColor(color4);
			element.PlayersElement.TextFormat = $"{info.LobbyInfo.PlayerCount}/{{1}} {{0}}";
			element.PlayersElement.Value = info.LobbyInfo.MaxPlayers;
			element.PrivacyElement.Cleared().WithTitle("Privacy");
			element.PrivacyElement.Value = info.LobbyInfo.Privacy;
			element.PrivacyElement.TextFormat = "{1}";
			element.ServerNameElement.Cleared().WithTitle("Server Name");
			element.ServerNameElement.EmptyFormat = "No {0}";
			element.ServerNameElement.TextFormat = "{1}";
			element.ServerNameElement.Value = TextFilter.FilterCommon(ParseServerName(info.LobbyInfo.LobbyName, info.LobbyInfo.LobbyHostName));
			element.HostNameElement.WithTitle(TextFilter.FilterCommonAndRichText(info.LobbyInfo.LobbyHostName));
			element.DescriptionElement.Cleared().WithTitle("Description");
			element.DescriptionElement.EmptyFormat = "No {0}";
			element.DescriptionElement.TextFormat = "{1}";
			element.DescriptionElement.Value = TextFilter.FilterCommon(info.LobbyInfo.LobbyDescription);
			element.MoreElement.Cleared().WithTitle("More...").Do(delegate
			{
				element.LobbyPage.SelectSubPage(1);
			});
			ElementIconHelper.SetLevelIcon(element, info.LobbyInfo.LevelTitle, info.LobbyInfo.LevelModID);
			ElementIconHelper.SetGamemodeIcon(element, info.LobbyInfo.GamemodeTitle);
			element.SettingsElement.Clear();
			PageElement pageElement = element.SettingsElement.AddPage();
			GroupElement groupElement = pageElement.AddElement<GroupElement>("General");
			groupElement.AddElement<BoolElement>("NameTags").WithInteractability(interactable: false).WithValue(info.LobbyInfo.NameTags);
			groupElement.AddElement<BoolElement>("VoiceChat").WithInteractability(interactable: false).WithValue(info.LobbyInfo.VoiceChat);
			groupElement.AddElement<EnumElement>("SlowMo").WithInteractability(interactable: false).WithValue(info.LobbyInfo.SlowMoMode);
			groupElement.AddElement<BoolElement>("Mortality").WithInteractability(interactable: false).WithValue(info.LobbyInfo.Mortality);
			groupElement.AddElement<BoolElement>("Friendly Fire").WithInteractability(interactable: false).WithValue(info.LobbyInfo.FriendlyFire);
			groupElement.AddElement<BoolElement>("Knockout").WithInteractability(interactable: false).WithValue(info.LobbyInfo.Knockout);
			groupElement.AddElement<IntElement>("Knockout Length").WithInteractability(interactable: false).WithValue(info.LobbyInfo.KnockoutLength);
			groupElement.AddElement<BoolElement>("Player Constraining").WithInteractability(interactable: false).WithValue(info.LobbyInfo.PlayerConstraining);
			groupElement.AddElement<FloatElement>("Max Avatar Height").WithInteractability(interactable: false).WithValue(info.LobbyInfo.MaxAvatarHeight);
			GroupElement groupElement2 = pageElement.AddElement<GroupElement>("Permissions");
			groupElement2.AddElement<EnumElement>("Dev Tools").WithInteractability(interactable: false).WithValue(info.LobbyInfo.DevTools);
			groupElement2.AddElement<EnumElement>("Constrainer").WithInteractability(interactable: false).WithValue(info.LobbyInfo.Constrainer);
			groupElement2.AddElement<EnumElement>("Custom Avatars").WithInteractability(interactable: false).WithValue(info.LobbyInfo.CustomAvatars);
			groupElement2.AddElement<EnumElement>("Kicking").WithInteractability(interactable: false).WithValue(info.LobbyInfo.Kicking);
			groupElement2.AddElement<EnumElement>("Banning").WithInteractability(interactable: false).WithValue(info.LobbyInfo.Banning);
			groupElement2.AddElement<EnumElement>("Teleportation").WithInteractability(interactable: false).WithValue(info.LobbyInfo.Teleportation);
			element.PlayerBrowserElement.Clear();
			PageElement pageElement2 = element.PlayerBrowserElement.AddPage();
			PlayerInfo[] players = info.LobbyInfo.PlayerList.Players;
			foreach (PlayerInfo player in players)
			{
				string text = TextFilter.FilterCommonAndRichText(player.Username);
				PlayerResultElement playerResultElement = pageElement2.AddElement<PlayerResultElement>(text);
				playerResultElement.GetReferences();
				playerResultElement.PlayerNameText.text = text;
				playerResultElement.RoleText.text = player.PermissionLevel.ToString();
				playerResultElement.OnPressed = delegate
				{
					OnShowPlayer(player);
				};
				ElementIconHelper.SetProfileResultIcon(playerResultElement, player.AvatarTitle, player.AvatarModID);
			}
			element.CodeGrid.SetActive(false);
			element.BansGrid.SetActive(false);
		}

		private static void ApplyPlayerToElement(PlayerElement element, PlayerInfo info)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			element.UsernameElement.Title = TextFilter.FilterCommonAndRichText(info.Username);
			element.NicknameElement.Title = "Nickname";
			element.NicknameElement.Value = TextFilter.FilterCommon(info.Nickname);
			element.NicknameElement.EmptyFormat = "No {0}";
			element.DescriptionElement.Title = "Description";
			element.DescriptionElement.Value = TextFilter.FilterCommon(info.Description);
			element.DescriptionElement.EmptyFormat = "No {0}";
			element.PermissionsElement.WithTitle("Permissions").WithColor(Color.yellow).WithInteractability(interactable: false);
			element.PermissionsElement.Value = info.PermissionLevel;
			element.PermissionsElement.EnumType = typeof(PermissionLevel);
			element.PlatformIDElement.WithTitle("Platform ID").WithColor(Color.red).WithInteractability(interactable: false);
			element.PlatformIDElement.Value = info.PlatformID.ToString();
			ElementIconHelper.SetProfileIcon(element, info.AvatarTitle, info.AvatarModID);
			((Component)element.VolumeElement).gameObject.SetActive(false);
		}
	}
	public static class MenuMatchmakingGamemodes
	{
		public static MenuPage GamemodesMenuPage { get; private set; }

		public static PageElement GamemodesPageElement { get; private set; }

		public static FunctionElement FindServerElement { get; private set; }

		public static FunctionElement CreateServerElement { get; private set; }

		public static LabelElement DescriptionLabel { get; private set; }

		public static LabelElement SearchingLabel { get; private set; }

		public static LabelElement NoneFoundLabel { get; private set; }

		public static FunctionElement CreateNewElement { get; private set; }

		public static Gamemode SelectedGamemode { get; private set; }

		private static void OnSearchFailure()
		{
			GamemodesMenuPage.Parent.SelectSubPage(GamemodesMenuPage);
			GamemodesMenuPage.SelectSubPage(2);
			string title = "No Gamemode servers found!\nCreate a new one?";
			if (SelectedGamemode != null)
			{
				title = "No " + SelectedGamemode.Title + " servers found!\nCreate a new one?";
			}
			NoneFoundLabel.Title = title;
		}

		private static void FindGamemodeServer()
		{
			GamemodesMenuPage.SelectSubPage(1);
			string title = "Searching for active Gamemode servers...";
			if (SelectedGamemode != null)
			{
				title = "Searching for active " + SelectedGamemode.Title + " servers...";
			}
			SearchingLabel.Title = title;
			IMatchmaker matchmaker = NetworkLayerManager.Layer.Matchmaker;
			if (matchmaker != null)
			{
				matchmaker.RequestLobbies(OnLobbiesRequested);
			}
			else
			{
				OnSearchFailure();
			}
		}

		private static void OnLobbiesRequested(IMatchmaker.MatchmakerCallbackInfo info)
		{
			string gamemodeBarcode = "Gamemode";
			if (SelectedGamemode != null)
			{
				gamemodeBarcode = SelectedGamemode.Barcode;
			}
			if (!MenuMatchmaking.LoadLobbiesIntoBrowser(from l in info.Lobbies
				where l.Metadata.LobbyInfo.GamemodeBarcode == gamemodeBarcode
				where LobbyFilterManager.CheckPersistentFilters(l.Lobby, l.Metadata)
				select l))
			{
				OnSearchFailure();
			}
		}

		private static void CreateGamemodeServer()
		{
			if (SelectedGamemode != null)
			{
				GamemodeHelper.StartGamemodeServer(SelectedGamemode);
			}
		}

		public static void PopulateGamemodes(Transform gamemodesTransform)
		{
			GamemodesMenuPage = ((Component)gamemodesTransform).GetComponent<MenuPage>();
			Transform obj = gamemodesTransform.Find("page_Query").Find("layout_Options");
			GamemodesPageElement = ((Component)obj.Find("scrollRect_Gamemodes/Viewport/Content")).GetComponent<PageElement>().AddPage();
			Transform obj2 = obj.Find("layout_Actions");
			FindServerElement = ((Component)obj2.Find("button_FindServer")).GetComponent<FunctionElement>().WithTitle("Find Server").Do(FindGamemodeServer);
			CreateServerElement = ((Component)obj2.Find("button_CreateServer")).GetComponent<FunctionElement>().WithTitle("Create Server").Do(CreateGamemodeServer);
			DescriptionLabel = ((Component)obj.Find("label_Description")).GetComponent<LabelElement>().WithTitle("No description...");
			SearchingLabel = ((Component)gamemodesTransform.Find("page_Searching").Find("label_Searching")).GetComponent<LabelElement>();
			SearchingLabel.Title = "Searching for active Gamemodes...";
			Transform obj3 = gamemodesTransform.Find("page_CreateNew").Find("layout_Options");
			NoneFoundLabel = ((Component)obj3.Find("label_NoneFound")).GetComponent<LabelElement>();
			CreateNewElement = ((Component)obj3.Find("button_CreateNew")).GetComponent<FunctionElement>().WithTitle("Create New").Do(CreateGamemodeServer);
			RefreshGamemodes();
		}

		private static void UpdateButtonVisibilities()
		{
			bool flag = SelectedGamemode != null;
			((Component)FindServerElement).gameObject.SetActive(flag);
			((Component)CreateServerElement).gameObject.SetActive(flag && !NetworkInfo.IsHost);
			((Component)DescriptionLabel).gameObject.SetActive(flag);
			if (flag)
			{
				string title = ((!string.IsNullOrWhiteSpace(SelectedGamemode.Description)) ? SelectedGamemode.Description : "No description...");
				DescriptionLabel.Title = title;
			}
		}

		public static void RefreshGamemodes()
		{
			GamemodeListHelper.RefreshGamemodeList(GamemodesPageElement, delegate(Gamemode gamemode)
			{
				SelectedGamemode = gamemode;
				UpdateButtonVisibilities();
			});
		}
	}
	public static class MenuMatchmakingSandbox
	{
		public static MenuPage SandboxMenuPage { get; private set; }

		public static FunctionElement QuickPlayElement { get; private set; }

		public static LabelElement SearchingLabel { get; private set; }

		public static LabelElement NoneFoundLabel { get; private set; }

		public static FunctionElement CreateNewElement { get; private set; }

		private static void OnSearchFailure()
		{
			SandboxMenuPage.Parent.SelectSubPage(SandboxMenuPage);
			SandboxMenuPage.SelectSubPage(2);
			string title = "No Sandbox servers found!\nCreate a new one?";
			NoneFoundLabel.Title = title;
		}

		private static void FindSandboxServer()
		{
			SandboxMenuPage.SelectSubPage(1);
			string title = "Searching for Sandbox servers...";
			SearchingLabel.Title = title;
			IMatchmaker matchmaker = NetworkLayerManager.Layer.Matchmaker;
			if (matchmaker != null)
			{
				matchmaker.RequestLobbies(MatchmakerFilters.Default, OnLobbiesRequested);
			}
			else
			{
				OnSearchFailure();
			}
		}

		private static bool CheckLobbyValidation(IMatchmaker.LobbyInfo lobby)
		{
			LobbyInfo lobbyInfo = lobby.Metadata.LobbyInfo;
			if (NetworkVerification.CompareVersion(lobbyInfo.LobbyVersion, FusionMod.Version) != VersionResult.Ok)
			{
				return false;
			}
			if (lobbyInfo.PlayerCount >= lobbyInfo.MaxPlayers)
			{
				return false;
			}
			if (!lobby.Metadata.ClientHasLevel)
			{
				return false;
			}
			if (!string.IsNullOrWhiteSpace(lobbyInfo.GamemodeBarcode))
			{
				return false;
			}
			return true;
		}

		private static void OnLobbiesRequested(IMatchmaker.MatchmakerCallbackInfo info)
		{
			IEnumerable<IMatchmaker.LobbyInfo> enumerable = MenuMatchmaking.ValidateLobbies(info.Lobbies.Where(CheckLobbyValidation));
			if (!enumerable.Any())
			{
				OnSearchFailure();
				return;
			}
			IMatchmaker.LobbyInfo random = enumerable.GetRandom();
			random.Metadata.CreateJoinDelegate(random.Lobby)?.Invoke();
		}

		private static void CreateSandboxServer()
		{
			if (NetworkInfo.HasServer)
			{
				NetworkHelper.Disconnect();
			}
			NetworkHelper.StartServer();
		}

		public static void PopulateSandbox(Transform sandboxTransform)
		{
			SandboxMenuPage = ((Component)sandboxTransform).GetComponent<MenuPage>();
			QuickPlayElement = ((Component)sandboxTransform.Find("page_QuickPlay").Find("button_QuickPlay")).GetComponent<FunctionElement>().WithTitle("Quick Play").Do(FindSandboxServer);
			SearchingLabel = ((Component)sandboxTransform.Find("page_Searching").Find("label_Searching")).GetComponent<LabelElement>();
			SearchingLabel.Title = "Searching for Sandbox servers...";
			Transform obj = sandboxTransform.Find("page_CreateNew").Find("layout_Options");
			NoneFoundLabel = ((Component)obj.Find("label_NoneFound")).GetComponent<LabelElement>();
			CreateNewElement = ((Component)obj.Find("button_CreateNew")).GetComponent<FunctionElement>().WithTitle("Create New").Do(CreateSandboxServer);
		}
	}
	public static class MenuButtonHelper
	{
		public static void PopulateTexts(GameObject root)
		{
			foreach (TMP_Text componentsInChild in root.GetComponentsInChildren<TMP_Text>(true))
			{
				componentsInChild.font = PersistentAssetCreator.Font;
			}
		}

		public static void PopulateButtons(GameObject root)
		{
			Transform obj = ((Component)UIRig.Instance).transform.Find("DATAMANAGER/CONTROL_FEEDBACK");
			Feedback_Tactile component = ((Component)obj).GetComponent<Feedback_Tactile>();
			Feedback_Audio component2 = ((Component)obj).GetComponent<Feedback_Audio>();
			foreach (Button componentsInChild in root.GetComponentsInChildren<Button>(true))
			{
				PopulateButton(componentsInChild, component, component2);
			}
		}

		public static void PopulateButton(Button button, Feedback_Tactile tacticle, Feedback_Audio audio)
		{
			ButtonHoverClick obj = ((Component)button).gameObject.AddComponent<ButtonHoverClick>();
			obj.feedback_tactile = tacticle;
			obj.feedback_audio = audio;
			obj.confirmer = true;
		}
	}
	public static class MenuChaining
	{
		public static EnumElement AsPref<TEnum>(this EnumElement element, FusionPref<TEnum> pref, Action<TEnum> onValueChanged = null) where TEnum : Enum
		{
			element.Value = pref.Value;
			element.EnumType = typeof(TEnum);
			EnumElement enumElement = element;
			enumElement.OnValueChanged = (Action<Enum>)Delegate.Combine(enumElement.OnValueChanged, new Action<Enum>(OnButtonChanged));
			FusionPref<TEnum> fusionPref = pref;
			fusionPref.OnValueChanged = (Action<TEnum>)Delegate.Combine(fusionPref.OnValueChanged, new Action<TEnum>(OnPrefChanged));
			element.OnCleared += delegate
			{
				EnumElement enumElement2 = element;
				enumElement2.OnValueChanged = (Action<Enum>)Delegate.Remove(enumElement2.OnValueChanged, new Action<Enum>(OnButtonChanged));
				FusionPref<TEnum> fusionPref2 = pref;
				fusionPref2.OnValueChanged = (Action<TEnum>)Delegate.Remove(fusionPref2.OnValueChanged, new Action<TEnum>(OnPrefChanged));
			};
			return element;
			void OnButtonChanged(Enum value)
			{
				pref.Value = (TEnum)value;
			}
			void OnPrefChanged(TEnum value)
			{
				if (element.Value.ToString() != value.ToString())
				{
					element.Value = value;
				}
				onValueChanged?.Invoke(value);
			}
		}

		public static StringElement AsPref(this StringElement element, FusionPref<string> pref, Action<string> onValueChanged = null)
		{
			element.Value = pref.Value;
			StringElement stringElement = element;
			stringElement.OnValueChanged = (Action<string>)Delegate.Combine(stringElement.OnValueChanged, new Action<string>(OnButtonChanged));
			FusionPref<string> fusionPref = pref;
			fusionPref.OnValueChanged = (Action<string>)Delegate.Combine(fusionPref.OnValueChanged, new Action<string>(OnPrefChanged));
			element.OnCleared += delegate
			{
				StringElement stringElement2 = element;
				stringElement2.OnValueChanged = (Action<string>)Delegate.Remove(stringElement2.OnValueChanged, new Action<string>(OnButtonChanged));
				FusionPref<string> fusionPref2 = pref;
				fusionPref2.OnValueChanged = (Action<string>)Delegate.Remove(fusionPref2.OnValueChanged, new Action<string>(OnPrefChanged));
			};
			return element;
			void OnButtonChanged(string value)
			{
				pref.Value = value;
			}
			void OnPrefChanged(string value)
			{
				if (element.Value != value)
				{
					element.Value = value;
				}
				onValueChanged?.Invoke(value);
			}
		}

		public static FloatElement AsPref(this FloatElement element, FusionPref<float> pref, Action<float> onValueChanged = null)
		{
			element.Value = pref.Value;
			FloatElement floatElement = element;
			floatElement.OnValueChanged = (Action<float>)Delegate.Combine(floatElement.OnValueChanged, new Action<float>(OnButtonChanged));
			FusionPref<float> fusionPref = pref;
			fusionPref.OnValueChanged = (Action<float>)Delegate.Combine(fusionPref.OnValueChanged, new Action<float>(OnPrefChanged));
			element.OnCleared += delegate
			{
				FloatElement floatElement2 = element;
				floatElement2.OnValueChanged = (Action<float>)Delegate.Remove(floatElement2.OnValueChanged, new Action<float>(OnButtonChanged));
				FusionPref<float> fusionPref2 = pref;
				fusionPref2.OnValueChanged = (Action<float>)Delegate.Remove(fusionPref2.OnValueChanged, new Action<float>(OnPrefChanged));
			};
			return element;
			void OnButtonChanged(float value)
			{
				pref.Value = value;
			}
			void OnPrefChanged(float value)
			{
				if (element.Value != value)
				{
					element.Value = value;
				}
				onValueChanged?.Invoke(value);
			}
		}

		public static IntElement AsPref(this IntElement element, FusionPref<int> pref, Action<int> onValueChanged = null)
		{
			element.Value = pref.Value;
			IntElement intElement = element;
			intElement.OnValueChanged = (Action<int>)Delegate.Combine(intElement.OnValueChanged, new Action<int>(OnButtonChanged));
			FusionPref<int> fusionPref = pref;
			fusionPref.OnValueChanged = (Action<int>)Delegate.Combine(fusionPref.OnValueChanged, new Action<int>(OnPrefChanged));
			element.OnCleared += delegate
			{
				IntElement intElement2 = element;
				intElement2.OnValueChanged = (Action<int>)Delegate.Remove(intElement2.OnValueChanged, new Action<int>(OnButtonChanged));
				FusionPref<int> fusionPref2 = pref;
				fusionPref2.OnValueChanged = (Action<int>)Delegate.Remove(fusionPref2.OnValueChanged, new Action<int>(OnPrefChanged));
			};
			return element;
			void OnButtonChanged(int value)
			{
				pref.Value = value;
			}
			void OnPrefChanged(int value)
			{
				if (element.Value != value)
				{
					element.Value = value;
				}
				onValueChanged?.Invoke(value);
			}
		}

		public static BoolElement AsPref(this BoolElement element, FusionPref<bool> pref, Action<bool> onValueChanged = null)
		{
			element.Value = pref.Value;
			BoolElement boolElement = element;
			boolElement.OnValueChanged = (Action<bool>)Delegate.Combine(boolElement.OnValueChanged, new Action<bool>(OnButtonChanged));
			FusionPref<bool> fusionPref = pref;
			fusionPref.OnValueChanged = (Action<bool>)Delegate.Combine(fusionPref.OnValueChanged, new Action<bool>(OnPrefChanged));
			element.OnCleared += delegate
			{
				BoolElement boolElement2 = element;
				boolElement2.OnValueChanged = (Action<bool>)Delegate.Remove(boolElement2.OnValueChanged, new Action<bool>(OnButtonChanged));
				FusionPref<bool> fusionPref2 = pref;
				fusionPref2.OnValueChanged = (Action<bool>)Delegate.Remove(fusionPref2.OnValueChanged, new Action<bool>(OnPrefChanged));
			};
			return element;
			void OnButtonChanged(bool value)
			{
				pref.Value = value;
			}
			void OnPrefChanged(bool value)
			{
				if (element.Value != value)
				{
					element.Value = value;
				}
				onValueChanged?.Invoke(value);
			}
		}

		public static FunctionElement Link(this FunctionElement element, PageElement page)
		{
			element.OnPressed = (Action)Delegate.Combine(element.OnPressed, new Action(page.Select));
			return element;
		}

		public static FunctionElement Do(this FunctionElement element, Action onPressed)
		{
			element.OnPressed = (Action)Delegate.Combine(element.OnPressed, onPressed);
			return element;
		}

		public static IntElement WithLimits(this IntElement element, int minValue, int maxValue)
		{
			element.MinValue = minValue;
			element.MaxValue = maxValue;
			return element;
		}

		public static IntElement WithIncrement(this IntElement element, int increment)
		{
			element.Increment = increment;
			return element;
		}

		public static IntElement WithValue(this IntElement element, int value)
		{
			element.Value = value;
			return element;
		}

		public static FloatElement WithLimits(this FloatElement element, float minValue, float maxValue)
		{
			element.MinValue = minValue;
			element.MaxValue = maxValue;
			return element;
		}

		public static FloatElement WithIncrement(this FloatElement element, float increment)
		{
			element.Increment = increment;
			return element;
		}

		public static FloatElement WithValue(this FloatElement element, float value)
		{
			element.Value = value;
			return element;
		}

		public static BoolElement WithValue(this BoolElement element, bool value)
		{
			element.Value = value;
			return element;
		}

		public static EnumElement WithValue(this EnumElement element, Enum value)
		{
			element.Value = value;
			return element;
		}

		public static StringElement WithValue(this StringElement element, string value)
		{
			element.Value = value;
			return element;
		}

		public static TElement WithTitle<TElement>(this TElement element, string title) where TElement : MenuElement
		{
			element.Title = title;
			return element;
		}

		public static TLabel WithColor<TLabel>(this TLabel element, Color color) where TLabel : LabelElement
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			element.Color = color;
			return element;
		}

		public static TButton WithInteractability<TButton>(this TButton button, bool interactable) where TButton : ButtonElement
		{
			button.Interactable = interactable;
			return button;
		}

		public static TElement Cleared<TElement>(this TElement element) where TElement : MenuElement
		{
			element.Clear();
			return element;
		}
	}
	public static class MenuCreator
	{
		private static int _menuPageIndex = -1;

		private static Image _menuButtonImage = null;

		private static MenuPopups _menuPopups = null;

		private static bool _isDownloadingContent = false;

		public static GameObject MenuGameObject { get; private set; } = null;


		public static int MenuPageIndex => _menuPageIndex;

		public static Image MenuButtonImage => _menuButtonImage;

		public static MenuPopups MenuPopups => _menuPopups;

		public static void OnInitializeMelon()
		{
			MenuPageHelper.OnInitializeMelon();
			MenuPopupsHelper.OnInitializeMelon();
		}

		public static void CreateMenu()
		{
			CreateMenuButton();
			SpawnMenu();
		}

		private static void CreateMenuButton()
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			UIRig instance = UIRig.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				Transform val = ((Component)instance.popUpMenu.preferencesPanelView).transform.Find("page_OPTIONS/grid_Options");
				GameObject gameObject = ((Component)val.Find("button_Control")).gameObject;
				GameObject obj = Object.Instantiate<GameObject>(gameObject, gameObject.transform.parent, false);
				((Object)obj).name = "button_Fusion";
				int siblingIndex = val.Find("button_Quit").GetSiblingIndex();
				obj.transform.SetSiblingIndex(siblingIndex - 1);
				TMP_Text component = ((Component)obj.transform.Find("text_Control")).GetComponent<TMP_Text>();
				component.text = "Fusion";
				((Object)((Component)component).gameObject).name = "text_Fusion";
				Button component2 = obj.GetComponent<Button>();
				component2.onClick = new ButtonClickedEvent();
				component2.AddClickEvent(OnMenuButtonClicked);
				_menuButtonImage = ((Component)obj.transform.Find("img_icon")).GetComponent<Image>();
			}
		}

		private static bool CheckFusionContent()
		{
			if (_isDownloadingContent)
			{
				return false;
			}
			switch (FusionPalletReferences.ValidateContentPallet())
			{
			default:
				Notifier.Send(new Notification
				{
					Title = "Missing Fusion Content",
					Message = "The Fusion Content mod is missing! Beginning download...",
					Type = NotificationType.INFORMATION,
					SaveToMenu = false,
					ShowPopup = true,
					PopupLength = 4f
				});
				DownloadContent();
				return false;
			case FusionPalletReferences.PalletStatus.OUTDATED:
				Notifier.Send(new Notification
				{
					Title = "Outdated Fusion Content",
					Message = "The installed Fusion Content mod is outdated! Updating...",
					Type = NotificationType.INFORMATION,
					SaveToMenu = false,
					ShowPopup = true,
					PopupLength = 4f
				});
				DownloadContent();
				return false;
			case FusionPalletReferences.PalletStatus.FOUND:
				return true;
			}
		}

		private static void DownloadContent()
		{
			_isDownloadingContent = true;
			ModIODownloader.EnqueueDownload(new ModTransaction
			{
				ModFile = new ModIOFile(4106243),
				Callback = OnCallbackReceived
			});
			static void OnCallbackReceived(DownloadCallbackInfo info)
			{
				_isDownloadingContent = false;
				if (info.Result != ModResult.SUCCEEDED)
				{
					Notifier.Send(new Notification
					{
						Title = "Download Failed",
						Message = "The Fusion Content failed to install! Make sure you are logged into mod.io in VoidG114 or BONELAB Hub!",
						Type = NotificationType.ERROR,
						SaveToMenu = false,
						ShowPopup = true,
						PopupLength = 4f
					});
				}
				else
				{
					SpawnMenu();
				}
			}
		}

		private static void OnMenuButtonClicked()
		{
			if (!CheckFusionContent())
			{
				return;
			}
			if (_menuPageIndex < 0)
			{
				Notifier.Send(new Notification
				{
					Title = "Failed to Open Menu",
					Message = "The Fusion menu does not exist! Please reinstall the Fusion Content mod.io mod!",
					Type = NotificationType.ERROR,
					SaveToMenu = false,
					ShowPopup = true,
					PopupLength = 6f
				});
				FusionLogger.Error("Tried opening the menu, but it doesn't exist! Please reinstall the Fusion Content mod.io mod!");
			}
			else
			{
				UIRig instance = UIRig.Instance;
				if (!((Object)(object)instance == (Object)null))
				{
					instance.popUpMenu.preferencesPanelView.PAGESELECT(_menuPageIndex);
				}
			}
		}

		private static void SpawnMenu()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (FusionPalletReferences.ValidateContentPallet() == FusionPalletReferences.PalletStatus.FOUND)
			{
				Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.FusionMenuReference);
				LocalAssetSpawner.Register(spawnable);
				LocalAssetSpawner.Spawn(spawnable, Vector3.zero, Quaternion.identity, OnMenuSpawned);
			}
		}

		private static void OnMenuSpawned(Poolee poolee)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			UIRig instance = UIRig.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				PreferencesPanelView preferencesPanelView = instance.popUpMenu.preferencesPanelView;
				MenuGameObject = ((Component)poolee).gameObject;
				Transform transform = ((Component)poolee).transform;
				transform.parent = ((Component)preferencesPanelView).transform;
				transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
				transform.localScale = Vector3.one;
				_menuPageIndex = InjectPage(preferencesPanelView, MenuGameObject);
				_menuPopups = MenuGameObject.GetComponentInChildren<MenuPopups>(true);
				MenuButtonHelper.PopulateTexts(MenuGameObject);
				MenuButtonHelper.PopulateButtons(MenuGameObject);
				MenuResources.GetResources(transform.Find("Resources"));
				MenuButtonImage.sprite = MenuResources.MenuIconSprite;
				((Component)transform.Find("button_BackArrow")).GetComponent<FunctionElement>().Do(OnBackArrowPressed);
				MenuPageHelper.PopulatePages(MenuGameObject);
				MenuPopupsHelper.PopulatePopups(((Component)transform.Find("Popups")).gameObject);
			}
		}

		private static void OnBackArrowPressed()
		{
			GoBack(MenuPageHelper.RootPage.RootCurrentPage);
		}

		private static void GoBack(MenuPage page)
		{
			MenuPage parent = page.Parent;
			if ((Object)(object)parent != (Object)null && (Object)(object)parent.Parent != (Object)null)
			{
				MenuPage parent2 = parent.Parent;
				if ((parent2.SubPages.Count <= 1 || parent.SubPages.IndexOf(parent.CurrentPage) == parent.DefaultPageIndex) && (Object)(object)parent2.Parent != (Object)null)
				{
					parent2.Parent.SelectSubPage(parent2);
				}
				else
				{
					parent2.SelectSubPage(parent);
				}
			}
			else
			{
				UIRig.Instance.popUpMenu.preferencesPanelView.PAGESELECT(0);
			}
		}

		private static int InjectPage(PreferencesPanelView panelView, GameObject page)
		{
			int num = ((Il2CppArrayBase<GameObject>)(object)panelView.pages).Length + 1;
			Il2CppReferenceArray<GameObject> val = new Il2CppReferenceArray<GameObject>((long)num);
			for (int i = 0; i < ((Il2CppArrayBase<GameObject>)(object)panelView.pages).Length; i++)
			{
				((Il2CppArrayBase<GameObject>)(object)val)[i] = ((Il2CppArrayBase<GameObject>)(object)panelView.pages)[i];
			}
			int num2 = num - 1;
			((Il2CppArrayBase<GameObject>)(object)val)[num2] = page;
			panelView.pages = val;
			return num2;
		}
	}
	public static class MenuResources
	{
		public const string ModsIconTitle = "Mods";

		public const string EmptyIconTitle = "Empty";

		public const string SandboxIconTitle = "Sandbox";

		private static Action _onResourcesReadyCallback;

		public static bool HasResources => (Object)(object)ResourcesTransform != (Object)null;

		public static Transform ResourcesTransform { get; private set; }

		public static Sprite MenuIconSprite { get; private set; }

		public static Dictionary<string, Texture> LevelIconLookup { get; private set; }

		public static Dictionary<string, Texture> AvatarIconLookup { get; private set; }

		public static Dictionary<string, Texture> GamemodeIconLookup { get; private set; }

		public static Dictionary<string, Texture> PointIconLookup { get; private set; }

		public static Dictionary<string, Texture> NotificationIconLookup { get; private set; }

		public static Dictionary<string, Texture> LogoIconLookup { get; private set; }

		public static Dictionary<string, Texture> AchievementIconLookup { get; private set; }

		public static Texture GetLevelIcon(string levelTitle)
		{
			return GetIcon(LevelIconLookup, levelTitle);
		}

		public static Texture GetAvatarIcon(string avatarTitle)
		{
			return GetIcon(AvatarIconLookup, avatarTitle);
		}

		public static Texture GetGamemodeIcon(string gamemodeTitle)
		{
			return GetIcon(GamemodeIconLookup, gamemodeTitle);
		}

		public static Texture GetPointIcon(string pointTitle)
		{
			return GetIcon(PointIconLookup, pointTitle);
		}

		public static Texture GetNotificationIcon(string notificationType)
		{
			return GetIcon(NotificationIconLookup, notificationType);
		}

		public static Texture GetLogoIcon(string logoTitle)
		{
			return GetIcon(LogoIconLookup, logoTitle);
		}

		public static Texture GetAchievementIcon(string achievementTitle)
		{
			return GetIcon(AchievementIconLookup, achievementTitle);
		}

		private static Texture GetIcon(Dictionary<string, Texture> lookup, string key)
		{
			if (string.IsNullOrWhiteSpace(key))
			{
				return null;
			}
			if (lookup.TryGetValue(key, out var value))
			{
				return value;
			}
			return null;
		}

		public static void GetResources(Transform resourcesTransform)
		{
			ResourcesTransform = resourcesTransform;
			Transform val = ResourcesTransform.Find("Menu Icon");
			if ((Object)(object)val != (Object)null)
			{
				MenuIconSprite = ((Component)val).GetComponent<SpriteRenderer>().sprite;
			}
			LevelIconLookup = LoadIcons(ResourcesTransform, "Level Icons");
			AvatarIconLookup = LoadIcons(ResourcesTransform, "Avatar Icons");
			GamemodeIconLookup = LoadIcons(ResourcesTransform, "Gamemode Icons");
			PointIconLookup = LoadIcons(ResourcesTransform, "Point Icons");
			NotificationIconLookup = LoadIcons(ResourcesTransform, "Notification Icons");
			LogoIconLookup = LoadIcons(ResourcesTransform, "Logo Icons");
			AchievementIconLookup = LoadIcons(ResourcesTransform, "Achievement Icons");
			_onResourcesReadyCallback?.Invoke();
			_onResourcesReadyCallback = null;
		}

		public static void HookResourcesReady(Action callback)
		{
			if (HasResources)
			{
				callback?.Invoke();
			}
			else
			{
				_onResourcesReadyCallback = (Action)Delegate.Combine(_onResourcesReadyCallback, callback);
			}
		}

		private static Dictionary<string, Texture> LoadIcons(Transform resources, string name)
		{
			Transform obj = resources.Find(name);
			Dictionary<string, Texture> dictionary = new Dictionary<string, Texture>();
			IEnumerator enumerator = obj.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Transform val = ((Il2CppObjectBase)enumerator.Current).TryCast<Transform>();
					if (!((Object)(object)val == (Object)null))
					{
						RawImage component = ((Component)val).GetComponent<RawImage>();
						if (!((Object)(object)component == (Object)null))
						{
							dictionary.Add(((Object)val).name, component.texture);
						}
					}
				}
				return dictionary;
			}
			finally
			{
				if (enumerator is IDisposable disposable)
				{
					disposable.Dispose();
				}
			}
		}
	}
	public static class MenuLocation
	{
		public static MenuPage LocationPage { get; private set; }

		public static LobbyElement LobbyElement { get; private set; }

		public static BoolElement NameTagsElement { get; private set; }

		public static BoolElement VoiceChatElement { get; private set; }

		public static EnumElement SlowMoElement { get; private set; }

		public static BoolElement MortalityElement { get; private set; }

		public static BoolElement FriendlyFireElement { get; private set; }

		public static BoolElement KnockoutElement { get; private set; }

		public static IntElement KnockoutLengthElement { get; private set; }

		public static BoolElement PlayerConstrainingElement { get; private set; }

		public static FloatElement MaxAvatarHeightElement { get; private set; }

		public static EnumElement DevToolsElement { get; private set; }

		public static EnumElement ConstrainerElement { get; private set; }

		public static EnumElement CustomAvatarsElement { get; private set; }

		public static EnumElement KickingElement { get; private set; }

		public static EnumElement BanningElement { get; private set; }

		public static EnumElement TeleportationElement { get; private set; }

		public static void OnInitializeMelon()
		{
			MultiplayerHooking.OnStartedServer += OnConnect;
			MultiplayerHooking.OnJoinedServer += OnConnect;
			MultiplayerHooking.OnDisconnected += OnDisconnect;
			LobbyInfoManager.OnLobbyInfoChanged += OnServerSettingsChanged;
			LocalPlayer.OnUsernameChanged += OnUsernameChanged;
		}

		private static void OnConnect()
		{
			if (!((Object)(object)LobbyElement == (Object)null))
			{
				PopulateLobbyAsServer(LobbyElement);
			}
		}

		private static void OnDisconnect()
		{
			if (!((Object)(object)LobbyElement == (Object)null))
			{
				PopulateLobbyNoServer(LobbyElement);
			}
		}

		private static void PopulateLobbyNoServer(LobbyElement element)
		{
			element.ServerActionElement.Cleared().WithTitle("Create Server").Do(NetworkHelper.StartServer);
			UpdateLobbyIcons(element);
			OnServerSettingsChanged();
		}

		private static void PopulateLobbyAsServer(LobbyElement element)
		{
			element.ServerActionElement.Cleared().WithTitle("Disconnect").Do(delegate
			{
				NetworkHelper.Disconnect();
			});
			UpdateLobbyIcons(element);
			OnServerSettingsChanged();
		}

		private static void UpdateLobbyIcons(LobbyElement element)
		{
			ElementIconHelper.SetLevelIcon(element, FusionSceneManager.Title, CrateFilterer.GetModID(((Crate)FusionSceneManager.Level).Pallet));
			ElementIconHelper.SetGamemodeIcon(element, GamemodeManager.ActiveGamemode?.Title);
		}

		private static void OnServerSettingsChanged()
		{
			if (!((Object)(object)LobbyElement == (Object)null))
			{
				if (NetworkInfo.IsClient)
				{
					ApplyLobbyInfoToLobby(LobbyElement, LobbyInfoManager.LobbyInfo);
				}
				else
				{
					ApplyServerSettingsToLobby(LobbyElement);
				}
			}
		}

		private static void OnUsernameChanged(string value)
		{
			if (!((Object)(object)LobbyElement == (Object)null) && !NetworkInfo.IsClient)
			{
				LobbyElement.HostNameElement.WithTitle(LocalPlayer.Username);
			}
		}

		private static void ApplyLobbyInfoToLobby(LobbyElement element, LobbyInfo info)
		{
			bool flag = NetworkInfo.IsHost || !NetworkInfo.HasServer;
			string emptyFormat = (flag ? "Click to add {0}" : "No {0}");
			element.LevelNameElement.WithTitle(FusionSceneManager.Title);
			element.ServerVersionElement.WithTitle($"v{FusionMod.Version}");
			int playerCount = PlayerIDManager.PlayerCount;
			element.PlayersElement.Cleared().WithIncrement(1).WithLimits(2, 255)
				.WithTitle("Players")
				.WithValue(info.MaxPlayers);
			element.PlayersElement.TextFormat = $"{playerCount}/{{1}} {{0}}";
			element.PrivacyElement.Cleared().WithTitle("Privacy").WithValue(info.Privacy);
			element.PrivacyElement.TextFormat = "{1}";
			element.ServerNameElement.Cleared().WithTitle("Server Name").WithValue(info.LobbyName.RemoveRichTextExceptColor());
			element.ServerNameElement.EmptyFormat = emptyFormat;
			element.ServerNameElement.TextFormat = "{1}";
			element.HostNameElement.WithTitle(info.LobbyHostName.RemoveRichText());
			element.DescriptionElement.Cleared().WithTitle("Description").WithValue(info.LobbyDescription.RemoveRichTextExceptColor());
			element.DescriptionElement.EmptyFormat = emptyFormat;
			element.DescriptionElement.TextFormat = "{1}";
			element.MoreElement.Cleared().WithTitle("More...").Do(delegate
			{
				element.LobbyPage.SelectSubPage(1);
			});
			NameTagsElement.Cleared().WithInteractability(flag).WithTitle("NameTags")
				.WithValue(info.NameTags);
			VoiceChatElement.Cleared().WithInteractability(flag).WithTitle("VoiceChat")
				.WithValue(info.VoiceChat);
			SlowMoElement.Cleared().WithInteractability(flag).WithTitle("SlowMo")
				.WithValue(info.SlowMoMode);
			MortalityElement.Cleared().WithInteractability(flag).WithTitle("Mortality")
				.WithValue(info.Mortality);
			FriendlyFireElement.Cleared().WithInteractability(flag).WithTitle("Friendly Fire")
				.WithValue(info.FriendlyFire);
			KnockoutElement.Cleared().WithInteractability(flag).WithTitle("Knockout")
				.WithValue(info.Knockout);
			KnockoutLengthElement.Cleared().WithInteractability(flag).WithTitle("Knockout Length")
				.WithValue(info.KnockoutLength);
			PlayerConstrainingElement.Cleared().WithInteractability(flag).WithTitle("Player Constraining")
				.WithValue(info.PlayerConstraining);
			MaxAvatarHeightElement.Cleared().WithInteractability(flag).WithTitle("Max Avatar Height")
				.WithValue(info.MaxAvatarHeight);
			DevToolsElement.Cleared().WithInteractability(flag).WithTitle("Dev Tools")
				.WithValue(info.DevTools);
			ConstrainerElement.Cleared().WithInteractability(flag).WithTitle("Constrainer")
				.WithValue(info.Constrainer);
			CustomAvatarsElement.Cleared().WithInteractability(flag).WithTitle("Custom Avatars")
				.WithValue(info.CustomAvatars);
			KickingElement.Cleared().WithInteractability(flag).WithTitle("Kicking")
				.WithValue(info.Kicking);
			BanningElement.Cleared().WithInteractability(flag).WithTitle("Banning")
				.WithValue(info.Banning);
			TeleportationElement.Cleared().WithInteractability(flag).WithTitle("Teleportation")
				.WithValue(info.Teleportation);
			RefreshPlayerList();
			element.CodeElement.Cleared().WithTitle("Code").WithInteractability(interactable: false);
			element.CodeElement.Value = NetworkHelper.GetServerCode();
			element.CodeElement.EmptyFormat = "No {0}";
			element.CodeRefreshElement.Cleared().WithInteractability(flag).Do(NetworkHelper.RefreshServerCode);
			element.BansGrid.SetActive(flag);
			element.AdminGrid.SetActive(flag);
			element.CodeGrid.SetActive(NetworkInfo.IsHost);
			element.Interactable = flag;
		}

		private static void ApplyServerSettingsToLobby(LobbyElement element)
		{
			bool flag = NetworkInfo.IsHost || !NetworkInfo.HasServer;
			string emptyFormat = (flag ? "Click to add {0}" : "No {0}");
			element.LevelNameElement.WithTitle(FusionSceneManager.Title);
			element.ServerVersionElement.WithTitle($"v{FusionMod.Version}");
			int playerCount = PlayerIDManager.PlayerCount;
			element.PlayersElement.Cleared().AsPref(SavedServerSettings.MaxPlayers).WithIncrement(1)
				.WithLimits(2, 255)
				.WithTitle("Players");
			element.PlayersElement.TextFormat = $"{playerCount}/{{1}} {{0}}";
			element.PrivacyElement.Cleared().AsPref(SavedServerSettings.Privacy).WithTitle("Privacy");
			element.PrivacyElement.TextFormat = "{1}";
			element.ServerNameElement.Cleared().AsPref(SavedServerSettings.ServerName).WithTitle("Server Name");
			element.ServerNameElement.EmptyFormat = emptyFormat;
			element.ServerNameElement.TextFormat = "{1}";
			element.HostNameElement.WithTitle(LocalPlayer.Username ?? "");
			element.DescriptionElement.Cleared().AsPref(SavedServerSettings.ServerDescription).WithTitle("Description");
			element.DescriptionElement.EmptyFormat = emptyFormat;
			element.DescriptionElement.TextFormat = "{1}";
			element.MoreElement.Cleared().WithTitle("More...").Do(delegate
			{
				element.LobbyPage.SelectSubPage(1);
			});
			NameTagsElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.NameTags)
				.WithTitle("NameTags");
			VoiceChatElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.VoiceChat)
				.WithTitle("VoiceChat");
			SlowMoElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.SlowMoMode)
				.WithTitle("SlowMo");
			MortalityElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.Mortality)
				.WithTitle("Mortality");
			FriendlyFireElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.FriendlyFire)
				.WithTitle("Friendly Fire");
			KnockoutElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.Knockout)
				.WithTitle("Knockout");
			KnockoutLengthElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.KnockoutLength)
				.WithLimits(5, 300)
				.WithIncrement(5)
				.WithTitle("Knockout Length");
			PlayerConstrainingElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.PlayerConstraining)
				.WithTitle("Player Constraining");
			MaxAvatarHeightElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.MaxAvatarHeight)
				.WithLimits(2f, 30f)
				.WithIncrement(1f)
				.WithTitle("Max Avatar Height");
			DevToolsElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.DevTools)
				.WithTitle("Dev Tools");
			ConstrainerElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.Constrainer)
				.WithTitle("Constrainer");
			CustomAvatarsElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.CustomAvatars)
				.WithTitle("Custom Avatars");
			KickingElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.Kicking)
				.WithTitle("Kicking");
			BanningElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.Banning)
				.WithTitle("Banning");
			TeleportationElement.Cleared().WithInteractability(flag).AsPref(SavedServerSettings.Teleportation)
				.WithTitle("Teleportation");
			RefreshPlayerList();
			element.CodeElement.Cleared().WithTitle("Code").WithInteractability(interactable: false);
			element.CodeElement.Value = NetworkHelper.GetServerCode();
			element.CodeElement.EmptyFormat = "No {0}";
			element.CodeRefreshElement.Cleared().WithInteractability(flag).Do(NetworkHelper.RefreshServerCode);
			element.BansGrid.SetActive(flag);
			element.AdminGrid.SetActive(flag);
			element.CodeGrid.SetActive(NetworkInfo.IsHost);
			element.Interactable = flag;
		}

		private static void RefreshPlayerList()
		{
			LobbyElement lobbyElement = LobbyElement;
			lobbyElement.PlayerBrowserElement.Clear();
			PageElement pageElement = lobbyElement.PlayerBrowserElement.AddPage();
			foreach (PlayerID player in PlayerIDManager.PlayerIDs)
			{
				player.TryGetDisplayName(out var name);
				PlayerResultElement playerResultElement = pageElement.AddElement<PlayerResultElement>(name);
				playerResultElement.GetReferences();
				playerResultElement.PlayerNameText.text = name;
				player.TryGetPermissionLevel(out var level);
				playerResultElement.RoleText.text = level.ToString();
				playerResultElement.OnPressed = delegate
				{
					OnShowPlayer(player);
				};
				string avatarTitle = player.Metadata.AvatarTitle.GetValue();
				int value = player.Metadata.AvatarModID.GetValue();
				if (NetworkPlayerManager.TryGetPlayer((byte)player, out NetworkPlayer player2) && player2.HasRig)
				{
					avatarTitle = ((Scannable)((CrateReferenceT<AvatarCrate>)(object)player2.RigRefs.RigManager.AvatarCrate).Crate).Title;
				}
				ElementIconHelper.SetProfileResultIcon(playerResultElement, avatarTitle, value);
			}
		}

		private static void RefreshBanList()
		{
			LobbyElement lobbyElement = LobbyElement;
			lobbyElement.BansElement.Clear();
			PageElement pageElement = lobbyElement.BansElement.AddPage();
			BanManager.ReadFile();
			foreach (BanInfo ban in BanManager.BanList.Bans)
			{
				PlayerInfo player = ban.Player;
				string text = player.Username.RemoveRichText();
				PlayerResultElement playerResultElement = pageElement.AddElement<PlayerResultElement>(text);
				playerResultElement.GetReferences();
				playerResultElement.PlayerNameText.text = text;
				playerResultElement.RoleText.text = "Banned";
				playerResultElement.OnPressed = delegate
				{
					OnShowBannedPlayer(player);
				};
				ElementIconHelper.SetProfileResultIcon(playerResultElement, player.AvatarTitle, player.AvatarModID);
			}
		}

		private static void OnShowPlayer(PlayerID player)
		{
			if (player.IsValid)
			{
				LobbyElement.LobbyPage.SelectSubPage(2);
				ApplyPlayerToElement(LobbyElement.ProfileElement, player);
			}
		}

		private static void OnShowBannedPlayer(PlayerInfo playerInfo)
		{
			LobbyElement.LobbyPage.SelectSubPage(2);
			ApplyBannedPlayerToElement(LobbyElement.ProfileElement, playerInfo);
		}

		private static void ApplyBannedPlayerToElement(PlayerElement element, PlayerInfo playerInfo)
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			string title = playerInfo.Username.RemoveRichText();
			element.UsernameElement.Title = title;
			element.NicknameElement.Title = "Nickname";
			element.NicknameElement.Value = playerInfo.Nickname.RemoveRichTextExceptColor();
			element.NicknameElement.Interactable = false;
			element.NicknameElement.EmptyFormat = "No {0}";
			element.DescriptionElement.Title = "Description";
			element.DescriptionElement.Interactable = false;
			element.DescriptionElement.EmptyFormat = "No {0}";
			string avatarTitle = playerInfo.AvatarTitle;
			ElementIconHelper.SetProfileIcon(element, avatarTitle, playerInfo.AvatarModID);
			_ = LobbyInfoManager.LobbyInfo;
			element.ActionsElement.Clear();
			element.ActionsElement.AddPage().AddElement<GroupElement>("Moderation").AddElement<FunctionElement>("Unban")
				.WithColor(Color.yellow)
				.Do(delegate
				{
					NetworkHelper.PardonUser(playerInfo.PlatformID);
				});
			((Component)element.PermissionsElement).gameObject.SetActive(false);
		}

		private static void ApplyPlayerToElement(PlayerElement element, PlayerID player)
		{
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			string username = TextFilter.FilterCommonAndRichText(player.Metadata.Username.GetValueOrEmpty());
			element.UsernameElement.Title = username;
			element.NicknameElement.Title = "Nickname";
			element.NicknameElement.Value = TextFilter.FilterCommon(player.Metadata.Nickname.GetValueOrEmpty());
			element.NicknameElement.Interactable = false;
			element.NicknameElement.EmptyFormat = "No {0}";
			element.DescriptionElement.Title = "Description";
			element.DescriptionElement.Value = TextFilter.FilterCommon(player.Metadata.Description.GetValueOrEmpty());
			element.DescriptionElement.Interactable = false;
			element.DescriptionElement.EmptyFormat = "No {0}";
			string valueOrEmpty = player.Metadata.AvatarTitle.GetValueOrEmpty();
			int value = player.Metadata.AvatarModID.GetValue();
			ElementIconHelper.SetProfileIcon(element, valueOrEmpty, value);
			FusionPermissions.FetchPermissionLevel(PlayerIDManager.LocalPlatformID, out var level, out var _);
			FusionPermissions.FetchPermissionLevel(player.PlatformID, out var level2, out var _);
			LobbyInfo lobbyInfo = LobbyInfoManager.LobbyInfo;
			if (player.IsMe)
			{
				((Component)element.VolumeElement).gameObject.SetActive(false);
			}
			else
			{
				FloatElement floatElement = element.VolumeElement.Cleared().WithTitle("Volume").WithIncrement(0.1f)
					.WithLimits(0f, 1f);
				((Component)floatElement).gameObject.SetActive(true);
				floatElement.Value = ContactsList.GetContact(player).volume;
				floatElement.OnValueChanged = (Action<float>)Delegate.Combine(floatElement.OnValueChanged, (Action<float>)delegate(float v)
				{
					Contact contact = ContactsList.GetContact(player);
					contact.volume = v;
					ContactsList.UpdateContact(contact);
				});
			}
			EnumElement enumElement = element.PermissionsElement.Cleared().WithTitle("Permissions").WithColor(Color.yellow);
			enumElement.EnumType = typeof(PermissionLevel);
			enumElement.Value = level2;
			enumElement.OnValueChanged = (Action<Enum>)Delegate.Combine(enumElement.OnValueChanged, (Action<Enum>)delegate(Enum v)
			{
				FusionPermissions.TrySetPermission(player.PlatformID, username, (PermissionLevel)(object)v);
			});
			enumElement.Interactable = !player.IsMe && NetworkInfo.IsHost;
			element.PlatformIDElement.Cleared().WithTitle("Platform ID").WithColor(Color.red)
				.WithInteractability(interactable: false)
				.Value = player.PlatformID.ToString();
			element.ActionsElement.Clear();
			PageElement actionsPage = element.ActionsElement.AddPage();
			AddModerationGroup(lobbyInfo, actionsPage, player, level, level2);
		}

		private static void AddModerationGroup(LobbyInfo lobbyInfo, PageElement actionsPage, PlayerID player, PermissionLevel selfLevel, PermissionLevel level)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			if (player.IsMe)
			{
				return;
			}
			bool num = FusionPermissions.HasSufficientPermissions(selfLevel, level) || NetworkInfo.IsHost;
			bool flag = FusionPermissions.HasHigherPermissions(selfLevel, level) || NetworkInfo.IsHost;
			if (!num && !flag)
			{
				return;
			}
			GroupElement groupElement = null;
			if (flag && FusionPermissions.HasSufficientPermissions(selfLevel, lobbyInfo.Kicking))
			{
				if (groupElement == null)
				{
					groupElement = actionsPage.AddElement<GroupElement>("Moderation");
				}
				groupElement.AddElement<FunctionElement>("Kick").WithColor(Color.red).Do(delegate
				{
					PermissionSender.SendPermissionRequest(PermissionCommandType.KICK, player);
				});
			}
			if (flag && FusionPermissions.HasSufficientPermissions(selfLevel, lobbyInfo.Banning))
			{
				if (groupElement == null)
				{
					groupElement = actionsPage.AddElement<GroupElement>("Moderation");
				}
				groupElement.AddElement<FunctionElement>("Ban").WithColor(Color.red).Do(delegate
				{
					PermissionSender.SendPermissionRequest(PermissionCommandType.BAN, player);
				});
			}
			if (FusionPermissions.HasSufficientPermissions(selfLevel, lobbyInfo.Teleportation))
			{
				if (groupElement == null)
				{
					groupElement = actionsPage.AddElement<GroupElement>("Moderation");
				}
				groupElement.AddElement<FunctionElement>("Teleport To Them").WithColor(Color.red).Do(delegate
				{
					PermissionSender.SendPermissionRequest(PermissionCommandType.TELEPORT_TO_THEM, player);
				});
				groupElement.AddElement<FunctionElement>("Teleport To Me").WithColor(Color.red).Do(delegate
				{
					PermissionSender.SendPermissionRequest(PermissionCommandType.TELEPORT_TO_ME, player);
				});
			}
		}

		public static void PopulateLocation(GameObject locationPage)
		{
			LocationPage = locationPage.GetComponent<MenuPage>();
			LobbyElement = ((Component)locationPage.transform.Find("panel_Lobby")).GetComponent<LobbyElement>();
			LobbyElement.GetElements();
			MenuPage lobbyPage = LobbyElement.LobbyPage;
			lobbyPage.OnShown = (Action)Delegate.Combine(lobbyPage.OnShown, (Action)delegate
			{
				RefreshPlayerList();
				RefreshBanList();
			});
			PopulateSettings(LobbyElement.SettingsElement.AddPage());
			PopulateAdmin(LobbyElement.AdminElement.AddPage());
			if (NetworkInfo.HasServer)
			{
				OnConnect();
			}
			else
			{
				OnDisconnect();
			}
		}

		private static void PopulateSettings(PageElement element)
		{
			GroupElement groupElement = element.AddElement<GroupElement>("General");
			NameTagsElement = groupElement.AddElement<BoolElement>("NameTags");
			VoiceChatElement = groupElement.AddElement<BoolElement>("VoiceChat");
			SlowMoElement = groupElement.AddElement<EnumElement>("SlowMo");
			MortalityElement = groupElement.AddElement<BoolElement>("Mortality");
			FriendlyFireElement = groupElement.AddElement<BoolElement>("Friendly Fire");
			KnockoutElement = groupElement.AddElement<BoolElement>("Knockout");
			KnockoutLengthElement = groupElement.AddElement<IntElement>("Knockout Length");
			PlayerConstrainingElement = groupElement.AddElement<BoolElement>("Player Constraining");
			MaxAvatarHeightElement = groupElement.AddElement<FloatElement>("Max Avatar Height");
			GroupElement groupElement2 = element.AddElement<GroupElement>("Permissions");
			DevToolsElement = groupElement2.AddElement<EnumElement>("Dev Tools");
			ConstrainerElement = groupElement2.AddElement<EnumElement>("Constrainer");
			CustomAvatarsElement = groupElement2.AddElement<EnumElement>("Custom Avatars");
			KickingElement = groupElement2.AddElement<EnumElement>("Kicking");
			BanningElement = groupElement2.AddElement<EnumElement>("Banning");
			TeleportationElement = groupElement2.AddElement<EnumElement>("Teleportation");
		}

		private static void PopulateAdmin(PageElement element)
		{
			element.AddElement<GroupElement>("Cleanup").AddElement<FunctionElement>("Despawn All").Do(delegate
			{
				PooleeUtilities.DespawnAll();
			});
			GroupElement groupElement = element.AddElement<GroupElement>("Players");
			FusionPermissions.FetchPermissionLevel(PlayerIDManager.LocalPlatformID, out var selfLevel, out var _);
			LobbyInfo activeLobbyInfo = LobbyInfoManager.LobbyInfo;
			groupElement.AddElement<FunctionElement>("Teleport All").Do(delegate
			{
				if (FusionPermissions.HasSufficientPermissions(selfLevel, activeLobbyInfo.Teleportation))
				{
					foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
					{
						if ((byte)playerID != PlayerIDManager.LocalSmallID)
						{
							PermissionSender.SendPermissionRequest(PermissionCommandType.TELEPORT_TO_ME, playerID);
						}
					}
				}
			});
		}
	}
	public static class MenuLogIn
	{
		private static int _lastLayerIndex = -1;

		public static FunctionElement ChangeLayerElement { get; private set; } = null;


		private static void OnLogInPageShown()
		{
			((Component)ChangeLayerElement).gameObject.SetActive(NetworkLayer.SupportedLayers.Count > 1);
		}

		public static void PopulateLogIn(GameObject logInGameObject)
		{
			MenuPage component = logInGameObject.GetComponent<MenuPage>();
			component.OnShown = (Action)Delegate.Combine(component.OnShown, new Action(OnLogInPageShown));
			Transform val = logInGameObject.transform.Find("panel_Layer").Find("layout_Options");
			LabelElement targetLayerLabel = ((Component)val.Find("label_TargetLayer")).GetComponent<LabelElement>();
			NetworkLayer targetLayer = NetworkLayerManager.GetTargetLayer();
			targetLayerLabel.Title = ((targetLayer != null) ? ("Target Layer: " + targetLayer.Title) : "No Target Layer");
			ChangeLayerElement = ((Component)val.Find("button_CycleLayer")).GetComponent<FunctionElement>().WithTitle("Change Layer").Do(delegate
			{
				int count = NetworkLayer.SupportedLayers.Count;
				if (count > 0)
				{
					_lastLayerIndex++;
					if (count <= _lastLayerIndex)
					{
						_lastLayerIndex = 0;
					}
					ClientSettings.NetworkLayerTitle.Value = NetworkLayer.SupportedLayers[_lastLayerIndex].Title;
				}
			});
			FusionPref<string> networkLayerTitle = ClientSettings.NetworkLayerTitle;
			networkLayerTitle.OnValueChanged = (Action<string>)Delegate.Combine(networkLayerTitle.OnValueChanged, (Action<string>)delegate(string v)
			{
				targetLayerLabel.Title = "Target Layer: " + v;
			});
			((Component)val.Find("button_LogIn")).GetComponent<FunctionElement>().WithTitle("Log In").Do(delegate
			{
				NetworkLayer targetLayer2 = NetworkLayerManager.GetTargetLayer();
				if (targetLayer2 != null)
				{
					NetworkLayerManager.LogIn(targetLayer2);
				}
			});
			((Component)logInGameObject.transform.Find("panel_Connecting").Find("label_Connecting")).GetComponent<LabelElement>().WithTitle("Connecting");
			((Component)logInGameObject.transform.Find("panel_Failed").Find("label_Failed")).GetComponent<LabelElement>().WithTitle("Connection Failed");
			((Component)logInGameObject.transform.Find("panel_Success").Find("label_Success")).GetComponent<LabelElement>().WithTitle("Connection Succeeded");
			OnLogInPageShown();
		}
	}
	public static class MenuNotifications
	{
		public static TMP_Text NotificationCountText { get; private set; } = null;


		public static PageElement NotificationPageElement { get; private set; } = null;


		public static List<Notification> SavedNotifications { get; private set; } = new List<Notification>();


		public static void PopulateNotifications(GameObject notificationsPage)
		{
			Transform obj = notificationsPage.transform.Find("layout_Top");
			NotificationCountText = ((Component)obj.Find("text_NotificationCount")).GetComponent<TMP_Text>();
			((Component)obj.Find("button_Clear")).GetComponent<FunctionElement>().Do(ClearNotifications);
			NotificationPageElement = ((Component)notificationsPage.transform.Find("scrollRect_Notifications/Viewport/Content")).GetComponent<PageElement>().AddPage();
			RecreateNotifications();
			UpdateCount();
		}

		private static void UpdateCount()
		{
			if (!((Object)(object)NotificationCountText == (Object)null))
			{
				int count = SavedNotifications.Count;
				if (count <= 0)
				{
					NotificationCountText.text = "You have no notifications.";
					return;
				}
				NotificationCountText.text = $"You have {count} notification{((count == 1) ? string.Empty : "s")}.";
			}
		}

		public static void ClearNotifications()
		{
			if (!((Object)(object)NotificationPageElement == (Object)null))
			{
				SavedNotifications.Clear();
				NotificationPageElement.RemoveElements();
				UpdateCount();
			}
		}

		private static void RecreateNotifications()
		{
			foreach (Notification savedNotification in SavedNotifications)
			{
				CreateNotification(savedNotification);
			}
		}

		public static void AddNotification(Notification notification)
		{
			SavedNotifications.Insert(0, notification);
			CreateNotification(notification);
		}

		private static void CreateNotification(Notification notification)
		{
			NotificationElement notificationElement;
			if (!((Object)(object)NotificationPageElement == (Object)null))
			{
				notificationElement = NotificationPageElement.AddElement<NotificationElement>(notification.Title.Text);
				notificationElement.GetReferences();
				notificationElement.TitleText.text = notification.Title.Text;
				notificationElement.MessageText.text = notification.Message.Text;
				NotificationElement notificationElement2 = notificationElement;
				notificationElement2.OnAccepted = (Action)Delegate.Combine(notificationElement2.OnAccepted, new Action(OnAccepted));
				NotificationElement notificationElement3 = notificationElement;
				notificationElement3.OnDeclined = (Action)Delegate.Combine(notificationElement3.OnDeclined, new Action(OnDeclined));
				if (notification.OnAccepted == null && notification.OnDeclined == null)
				{
					notificationElement.DeclineButton.SetActive(false);
				}
				UpdateCount();
			}
			void OnAccepted()
			{
				notification.OnAccepted?.InvokeSafe("executing FusionNotification.OnAccepted");
				RemoveNotification();
			}
			void OnDeclined()
			{
				notification.OnDeclined?.InvokeSafe("executing FusionNotification.OnDeclined");
				RemoveNotification();
			}
			void RemoveNotification()
			{
				NotificationPageElement.RemoveElement(notificationElement);
				SavedNotifications.Remove(notification);
				UpdateCount();
			}
		}
	}
	public static class MenuPageHelper
	{
		public static Vector3 DefaultScale { get; private set; } = Vector3.one;


		public static Transform MenuParent { get; private set; } = null;


		public static MenuPage RootPage { get; private set; } = null;


		public static FunctionElement LogOutElement { get; private set; } = null;


		public static void OnInitializeMelon()
		{
			MenuProfile.OnInitializeMelon();
			MenuLocation.OnInitializeMelon();
			MenuGamemode.OnInitializeMelon();
			NetworkLayerManager.OnLoggedInChanged += OnLoggedInChanged;
			FusionPref<float> menuSize = ClientSettings.MenuSize;
			menuSize.OnValueChanged = (Action<float>)Delegate.Combine(menuSize.OnValueChanged, new Action<float>(OnMenuSizeChanged));
		}

		private static void OnMenuSizeChanged(float value)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)RootPage == (Object)null) && ((Behaviour)RootPage).isActiveAndEnabled)
			{
				MenuParent.localScale = DefaultScale * value;
			}
		}

		private static void OnMenuOpened()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)MenuParent == (Object)null))
			{
				MenuParent.localScale = DefaultScale * ClientSettings.MenuSize.Value;
			}
		}

		private static void OnMenuClosed()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)MenuParent == (Object)null))
			{
				MenuParent.localScale = DefaultScale;
			}
		}

		public static void PopulatePages(GameObject root)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			RootPage = root.GetComponent<MenuPage>();
			MenuPage rootPage = RootPage;
			rootPage.OnEnabled = (Action)Delegate.Combine(rootPage.OnEnabled, new Action(OnMenuOpened));
			MenuPage rootPage2 = RootPage;
			rootPage2.OnDisabled = (Action)Delegate.Combine(rootPage2.OnDisabled, new Action(OnMenuClosed));
			Transform transform = root.transform;
			MenuParent = transform.parent;
			DefaultScale = MenuParent.localScale;
			MenuProfile.PopulateProfile(((Component)transform.Find("page_Profile")).gameObject);
			MenuLocation.PopulateLocation(((Component)transform.Find("page_Location")).gameObject);
			MenuMatchmaking.PopulateMatchmaking(((Component)transform.Find("page_Matchmaking")).gameObject);
			MenuGamemode.PopulateGamemode(((Component)transform.Find("page_Gamemode")).gameObject);
			MenuNotifications.PopulateNotifications(((Component)transform.Find("page_Notifications")).gameObject);
			MenuLogIn.PopulateLogIn(((Component)transform.Find("page_LogIn")).gameObject);
			LogOutElement = ((Component)transform.Find("button_LogOut")).GetComponent<FunctionElement>().Do(OnLogOutPressed);
			UpdateLogIn();
		}

		private static void OnLoggedInChanged(bool value)
		{
			UpdateLogIn();
		}

		private static void UpdateLogIn()
		{
			if (NetworkLayerManager.LoggedIn)
			{
				OnLoggedIn();
			}
			else
			{
				OnLoggedOut();
			}
		}

		private static void OnLoggedIn()
		{
			if (!((Object)(object)RootPage == (Object)null))
			{
				MenuSettings.PopulateSettings(((Component)((Component)RootPage).transform.Find("page_Settings")).gameObject);
				RootPage.DefaultPageIndex = 0;
				RootPage.SelectSubPage(0);
				((Component)LogOutElement).gameObject.SetActive(true);
			}
		}

		private static void OnLoggedOut()
		{
			if (!((Object)(object)RootPage == (Object)null))
			{
				RootPage.DefaultPageIndex = 6;
				RootPage.SelectSubPage(6);
				((Component)LogOutElement).gameObject.SetActive(false);
			}
		}

		private static void OnLogOutPressed()
		{
			NetworkLayerManager.LogOut();
		}
	}
	public static class MenuProfile
	{
		public static PlayerElement ProfileElement { get; private set; }

		private static string PreviousAvatarTitle { get; set; }

		public static void OnInitializeMelon()
		{
			LocalPlayer.OnUsernameChanged += delegate
			{
				RefreshName();
			};
		}

		private static void UpdatePlayerIcon(PlayerElement element)
		{
			AvatarCrate crate = ((CrateReferenceT<AvatarCrate>)(object)RigData.Refs.RigManager.AvatarCrate).Crate;
			string title = ((Scannable)crate).Title;
			if (!(title == PreviousAvatarTitle))
			{
				PreviousAvatarTitle = title;
				ElementIconHelper.SetProfileIcon(element, title, CrateFilterer.GetModID(((Crate)crate).Pallet));
			}
		}

		private static void RefreshIcon()
		{
			UpdatePlayerIcon(ProfileElement);
		}

		private static void RefreshName()
		{
			if (!((Object)(object)ProfileElement == (Object)null))
			{
				ProfileElement.UsernameElement.WithTitle(LocalPlayer.Username);
			}
		}

		public static void PopulateProfile(GameObject profilePage)
		{
			PreviousAvatarTitle = null;
			ProfileElement = ((Component)profilePage.transform.Find("panel_Profile")).GetComponent<PlayerElement>();
			ProfileElement.GetElements();
			ProfileElement.UsernameElement.WithTitle(LocalPlayer.Username);
			ProfileElement.NicknameElement.WithTitle("Nickname").AsPref(ClientSettings.Nickname);
			ProfileElement.DescriptionElement.WithTitle("Description").AsPref(ClientSettings.Description);
			MenuPage playerPage = ProfileElement.PlayerPage;
			playerPage.OnShown = (Action)Delegate.Combine(playerPage.OnShown, (Action)delegate
			{
				RefreshIcon();
			});
			RefreshIcon();
			ProfileElement.OptionsGameObject.SetActive(false);
			ProfileElement.ActionsGrid.SetActive(false);
		}
	}
	public static class MenuSettings
	{
		public static void PopulateSettings(GameObject settingsPage)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			PageElement component = ((Component)settingsPage.transform.Find("scrollRect_Options/Viewport/Content")).GetComponent<PageElement>();
			PageElement page = component.AddPage();
			PopulateClientSettings(page);
			PageElement page2 = component.AddPage();
			PopulateDownloadingSettings(page2);
			PageElement page3 = component.AddPage();
			PopulateSafetySettings(page3);
			PageElement pageElement = ((Component)settingsPage.transform.Find("scrollRect_Categories/Viewport/Content")).GetComponent<PageElement>().AddPage("Default");
			pageElement.AddElement<FunctionElement>("Client").Link(page).WithColor(Color.white);
			pageElement.AddElement<FunctionElement>("Downloading").Link(page2).WithColor(Color.cyan);
			pageElement.AddElement<FunctionElement>("Safety").Link(page3).WithColor(Color.yellow);
		}

		private static void PopulateClientSettings(PageElement page)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			GroupElement groupElement = page.AddElement<GroupElement>("Visuals");
			groupElement.AddElement<FloatElement>("Menu Size").AsPref(ClientSettings.MenuSize).WithIncrement(0.1f)
				.WithLimits(1f, 2f);
			groupElement.AddElement<BoolElement>("NameTags").AsPref(ClientSettings.NameTags);
			groupElement.AddElement<EnumElement>("Nickname Visibility").AsPref(ClientSettings.NicknameVisibility);
			groupElement.AddElement<BoolElement>("Mute Icon").AsPref(ClientSettings.VoiceChat.MutedIndicator);
			Color nameTagColor = ClientSettings.NameTagColor;
			GroupElement nameTagColorGroup = page.AddElement<GroupElement>("NameTag Color").WithColor(nameTagColor);
			nameTagColorGroup.AddElement<FloatElement>("Hue").WithIncrement(0.05f).WithLimits(0f, 1f)
				.AsPref(ClientSettings.NameTagHue, OnColorElementChanged);
			nameTagColorGroup.AddElement<FloatElement>("Saturation").WithIncrement(0.05f).WithLimits(0f, 1f)
				.AsPref(ClientSettings.NameTagSaturation, OnColorElementChanged);
			nameTagColorGroup.AddElement<FloatElement>("Value").WithIncrement(0.05f).WithLimits(0f, 1f)
				.AsPref(ClientSettings.NameTagValue, OnColorElementChanged);
			page.AddElement<GroupElement>("Voice Chat").AddElement<FloatElement>("Global Volume").AsPref(ClientSettings.VoiceChat.GlobalVolume)
				.WithLimits(0f, 1f)
				.WithIncrement(0.1f);
			PopulateInputDeviceGroup(page.AddElement<GroupElement>("Input Device"));
			void OnColorElementChanged(float value)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				nameTagColorGroup.Color = ClientSettings.NameTagColor;
			}
		}

		private static void PopulateInputDeviceGroup(GroupElement element)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			string[] inputDevices = VoiceInfo.InputDevices;
			FusionPref<string> inputPreference = ClientSettings.VoiceChat.InputDevice;
			Dictionary<string, FunctionElement> deviceElements = new Dictionary<string, FunctionElement>();
			FunctionElement value2 = element.AddElement<FunctionElement>("Default").WithColor(string.IsNullOrEmpty(inputPreference.Value) ? Color.green : Color.gray).Do(delegate
			{
				inputPreference.Value = string.Empty;
			});
			deviceElements.Add(string.Empty, value2);
			string[] array = inputDevices;
			foreach (string device in array)
			{
				Color color = ((inputPreference.Value == device) ? Color.green : Color.gray);
				FunctionElement value3 = element.AddElement<FunctionElement>(device).WithColor(color).Do(delegate
				{
					inputPreference.Value = device;
				});
				deviceElements.Add(device, value3);
			}
			FusionPref<string> fusionPref = inputPreference;
			fusionPref.OnValueChanged = (Action<string>)Delegate.Combine(fusionPref.OnValueChanged, new Action<string>(OnPrefChanged));
			element.OnCleared += delegate
			{
				FusionPref<string> fusionPref2 = inputPreference;
				fusionPref2.OnValueChanged = (Action<string>)Delegate.Remove(fusionPref2.OnValueChanged, new Action<string>(OnPrefChanged));
			};
			void OnPrefChanged(string value)
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				foreach (KeyValuePair<string, FunctionElement> item in deviceElements)
				{
					if (string.IsNullOrWhiteSpace(value) && string.IsNullOrEmpty(item.Key))
					{
						item.Value.Color = Color.green;
					}
					else if (value == item.Key)
					{
						item.Value.Color = Color.green;
					}
					else
					{
						item.Value.Color = Color.gray;
					}
				}
			}
		}

		private static void PopulateDownloadingSettings(PageElement page)
		{
			GroupElement groupElement = page.AddElement<GroupElement>("General");
			groupElement.AddElement<BoolElement>("Download Spawnables").AsPref(ClientSettings.Downloading.DownloadSpawnables);
			groupElement.AddElement<BoolElement>("Download Avatars").AsPref(ClientSettings.Downloading.DownloadAvatars);
			groupElement.AddElement<BoolElement>("Download Levels").AsPref(ClientSettings.Downloading.DownloadLevels);
			groupElement.AddElement<BoolElement>("Keep Downloaded Mods").AsPref(ClientSettings.Downloading.KeepDownloadedMods);
			groupElement.AddElement<BoolElement>("Notify Downloads").AsPref(ClientSettings.Downloading.NotifyDownloads);
			groupElement.AddElement<IntElement>("Max File Size (MB)").AsPref(ClientSettings.Downloading.MaxFileSize).WithIncrement(10)
				.WithLimits(0, 10000);
			groupElement.AddElement<IntElement>("Max Level Size (MB)").AsPref(ClientSettings.Downloading.MaxLevelSize).WithIncrement(100)
				.WithLimits(0, 10000);
		}

		private static void PopulateSafetySettings(PageElement page)
		{
			page.AddElement<GroupElement>("General").AddElement<BoolElement>("Filter Profanity").AsPref(ClientSettings.Safety.FilterProfanity);
		}
	}
	public static class MenuKeyboardHelper
	{
		public static bool KeyboardOpened
		{
			get
			{
				MenuPopups menuPopups = MenuCreator.MenuPopups;
				if ((Object)(object)menuPopups == (Object)null)
				{
					return false;
				}
				return menuPopups.Keyboard.Opened;
			}
		}

		public static void AssignKeyboardToButton(StringElement button)
		{
			MenuPopups menuPopups = MenuCreator.MenuPopups;
			if (!((Object)(object)menuPopups == (Object)null))
			{
				Keyboard keyboard = menuPopups.Keyboard;
				keyboard.Open();
				keyboard.TemporaryUppercase = false;
				keyboard.Uppercase = false;
				keyboard.Value = button.Value;
				keyboard.OnValueChanged = delegate(string value)
				{
					button.Value = value;
				};
				keyboard.OnEnter = delegate
				{
					button.Submit();
				};
				keyboard.OnClose = (Action)Delegate.Combine(keyboard.OnClose, new Action(OnAssignedKeyboardClose));
			}
		}

		private static void OnAssignedKeyboardClose()
		{
			MenuPopups menuPopups = MenuCreator.MenuPopups;
			if (!((Object)(object)menuPopups == (Object)null))
			{
				Keyboard keyboard = menuPopups.Keyboard;
				keyboard.OnClose = (Action)Delegate.Remove(keyboard.OnClose, new Action(OnAssignedKeyboardClose));
				keyboard.OnValueChanged = null;
				keyboard.OnEnter = null;
			}
		}

		public static void CloseKeyboard()
		{
			MenuPopups menuPopups = MenuCreator.MenuPopups;
			if (!((Object)(object)menuPopups == (Object)null))
			{
				menuPopups.Keyboard.Close();
			}
		}
	}
	public static class MenuPopupsHelper
	{
		public static GameObject PopupsRoot { get; private set; }

		public static void OnInitializeMelon()
		{
			MenuToolbarHelper.OnInitializeMelon();
			NetworkLayerManager.OnLoggedInChanged += OnLoggedInChanged;
		}

		public static void PopulatePopups(GameObject popups)
		{
			PopupsRoot = popups;
			MenuToolbarHelper.PopulateToolbar(((Component)popups.transform.Find("grid_Toolbar")).gameObject);
			UpdateLogIn();
		}

		private static void OnLoggedInChanged(bool value)
		{
			UpdateLogIn();
		}

		private static void UpdateLogIn()
		{
			if (NetworkLayerManager.LoggedIn)
			{
				OnLoggedIn();
			}
			else
			{
				OnLoggedOut();
			}
		}

		private static void OnLoggedIn()
		{
			if (!((Object)(object)PopupsRoot == (Object)null))
			{
				PopupsRoot.SetActive(true);
			}
		}

		private static void OnLoggedOut()
		{
			if (!((Object)(object)PopupsRoot == (Object)null))
			{
				PopupsRoot.SetActive(false);
			}
		}
	}
	public static class MenuToolbarHelper
	{
		public static GameObject GamemodeButton { get; private set; }

		public static void OnInitializeMelon()
		{
			LobbyInfoManager.OnLobbyInfoChanged += UpdateToolbar;
		}

		public static void PopulateToolbar(GameObject toolbar)
		{
			((Component)toolbar.transform.Find("button_Muted")).GetComponent<BoolElement>().AsPref(ClientSettings.VoiceChat.Muted);
			((Component)toolbar.transform.Find("button_Deafened")).GetComponent<BoolElement>().AsPref(ClientSettings.VoiceChat.Deafened);
			GamemodeButton = ((Component)toolbar.transform.Find("button_Gamemode")).gameObject;
			UpdateToolbar();
		}

		private static void UpdateToolbar()
		{
			if ((Object)(object)GamemodeButton != (Object)null)
			{
				GamemodeButton.SetActive(NetworkInfo.HasServer);
			}
		}
	}
}
namespace LabFusion.Menu.Gamemodes
{
	public static class GamemodeListHelper
	{
		public static void RefreshGamemodeList(PageElement pageElement, Action<Gamemode> onGamemodeSelected = null)
		{
			pageElement.Clear();
			List<GamemodeResultElement> resultElements = new List<GamemodeResultElement>();
			foreach (Gamemode gamemode in GamemodeManager.Gamemodes)
			{
				GamemodeResultElement gamemodeResult = pageElement.AddElement<GamemodeResultElement>(gamemode.Title);
				resultElements.Add(gamemodeResult);
				gamemodeResult.GetReferences();
				gamemodeResult.GamemodeNameText.text = gamemode.Title;
				Texture texture = (Object.op_Implicit((Object)(object)gamemode.Logo) ? gamemode.Logo : MenuResources.GetGamemodeIcon("Mods"));
				gamemodeResult.GamemodeIcon.texture = texture;
				GamemodeResultElement gamemodeResultElement = gamemodeResult;
				gamemodeResultElement.OnPressed = (Action)Delegate.Combine(gamemodeResultElement.OnPressed, (Action)delegate
				{
					foreach (GamemodeResultElement item in resultElements)
					{
						item.Highlight(highlighted: false);
					}
					gamemodeResult.Highlight(highlighted: true);
					onGamemodeSelected?.Invoke(gamemode);
				});
			}
			onGamemodeSelected?.Invoke(null);
		}
	}
	public static class MenuGamemode
	{
		public static MenuPage GamemodePage { get; private set; }

		public static MenuPage OverviewPage { get; private set; }

		public static RawImage GamemodeIcon { get; private set; }

		public static LabelElement GamemodeTitle { get; private set; }

		public static LabelElement GamemodeReadyElement { get; private set; }

		public static LabelElement GamemodeStartedElement { get; private set; }

		public static GameObject GamemodeSelectionGrid { get; private set; }

		public static GameObject SettingsGrid { get; private set; }

		public static PageElement SettingsPageElement { get; private set; }

		public static PageElement GamemodesPageElement { get; private set; }

		public static FunctionElement SelectGamemodeElement { get; private set; }

		public static FunctionElement ExitGamemodeElement { get; private set; }

		public static Gamemode SelectedGamemode { get; private set; }

		public static void OnInitializeMelon()
		{
			GamemodeManager.OnGamemodeChanged += OnGamemodeChanged;
			GamemodeManager.OnGamemodeStarted += OnGamemodeStarted;
			GamemodeManager.OnGamemodeStopped += OnGamemodeStopped;
			GamemodeManager.OnGamemodeReady += OnGamemodeReady;
			GamemodeManager.OnGamemodeUnready += OnGamemodeUnready;
			GamemodeManager.OnStartTimerChanged += OnStartTimerChanged;
		}

		private static void OnGamemodeChanged(Gamemode gamemode)
		{
			UpdateMenuGamemode();
		}

		private static void OnGamemodeStarted()
		{
			UpdateMenuGamemode();
		}

		private static void OnGamemodeStopped()
		{
			UpdateMenuGamemode();
		}

		private static void OnGamemodeReady()
		{
			UpdateReadyLabel();
		}

		private static void OnGamemodeUnready()
		{
			UpdateReadyLabel();
		}

		private static void OnStartTimerChanged(float value)
		{
			UpdateStartedLabel();
		}

		private static void UpdateStartedLabel()
		{
			if (GamemodeManager.StartTimerActive)
			{
				GamemodeStartedElement.Title = $"Starting in {Mathf.CeilToInt(GamemodeManager.StartTimer)} seconds...";
			}
			else
			{
				GamemodeStartedElement.Title = (GamemodeManager.IsGamemodeStarted ? "Started" : "Not Started") ?? "";
			}
		}

		private static void UpdateReadyLabel()
		{
			GamemodeReadyElement.Title = (GamemodeManager.IsGamemodeReady ? "Ready" : "Not Ready") ?? "";
		}

		private static void OverrideSettingsPage(Gamemode gamemode)
		{
			if (GamemodeManager.ActiveGamemode != null)
			{
				return;
			}
			SettingsPageElement.Clear();
			if (gamemode == null)
			{
				SettingsGrid.SetActive(false);
				return;
			}
			SettingsGrid.SetActive(true);
			if (NetworkInfo.IsHost)
			{
				ApplySettingsData(gamemode);
			}
		}

		private static void ApplySettingsData(Gamemode gamemode)
		{
			SettingsPageElement.AddElement<FunctionElement>("Round Settings").Do(OpenRoundSettings);
			GroupElementData groupElementData = gamemode.CreateSettingsGroup();
			if (groupElementData.Elements.Count > 0)
			{
				ElementDataHelper.ApplyGroupData(SettingsPageElement, groupElementData);
			}
		}

		private static void OpenRoundSettings()
		{
			Gamemode gamemode = GamemodeManager.ActiveGamemode ?? SelectedGamemode;
			if (gamemode != null)
			{
				GamemodePage.SelectSubPage(MenuGamemodeRounds.RoundsPage);
				MenuGamemodeRounds.ShowLevelRotations(gamemode.Barcode);
			}
		}

		private static void UpdateMenuGamemode()
		{
			if (!((Object)(object)GamemodeIcon == (Object)null))
			{
				SettingsPageElement.Clear();
				SettingsGrid.SetActive(true);
				GamemodeSelectionGrid.gameObject.SetActive(NetworkInfo.IsHost);
				Gamemode activeGamemode = GamemodeManager.ActiveGamemode;
				if (activeGamemode != null)
				{
					Texture texture = (Object.op_Implicit((Object)(object)activeGamemode.Logo) ? activeGamemode.Logo : MenuResources.GetGamemodeIcon("Mods"));
					GamemodeIcon.texture = texture;
					GamemodeTitle.Title = activeGamemode.Title;
					GamemodeSelectionGrid.gameObject.SetActive(NetworkInfo.IsHost);
					ApplySettingsData(activeGamemode);
					((Component)GamemodeReadyElement).gameObject.SetActive(true);
					((Component)GamemodeStartedElement).gameObject.SetActive(true);
					UpdateReadyLabel();
					UpdateStartedLabel();
				}
				else
				{
					GamemodeIcon.texture = MenuResources.GetGamemodeIcon("Sandbox");
					GamemodeTitle.Title = "Sandbox";
					((Component)GamemodeReadyElement).gameObject.SetActive(false);
					((Component)GamemodeStartedElement).gameObject.SetActive(false);
					RefreshGamemodes();
				}
				UpdateActionElements();
			}
		}

		private static void OnSelectGamemodePressed()
		{
			if (SelectedGamemode != null)
			{
				GamemodeManager.SelectGamemode(SelectedGamemode);
			}
		}

		private static void OnExitGamemodePressed()
		{
			GamemodeManager.DeselectGamemode();
		}

		public static void PopulateGamemode(GameObject gamemodePage)
		{
			GamemodePage = gamemodePage.GetComponent<MenuPage>();
			Transform obj = gamemodePage.transform.Find("page_Overview");
			OverviewPage = ((Component)obj).GetComponent<MenuPage>();
			Transform obj2 = obj.Find("grid_GamemodeOptions");
			GamemodeIcon = ((Component)obj2.Find("label_GamemodeIcon/icon_Mask/icon_Gamemode")).GetComponent<RawImage>();
			GamemodeTitle = ((Component)obj2.Find("label_GamemodeTitle")).GetComponent<LabelElement>();
			GamemodeReadyElement = ((Component)obj2.Find("label_GamemodeReady")).GetComponent<LabelElement>();
			GamemodeStartedElement = ((Component)obj2.Find("label_GamemodeStarted")).GetComponent<LabelElement>();
			Transform obj3 = obj.Find("grid_GamemodeSelection");
			GamemodeSelectionGrid = ((Component)obj3).gameObject;
			SettingsGrid = ((Component)obj3.Find("grid_Settings")).gameObject;
			SettingsPageElement = ((Component)SettingsGrid.transform.Find("scrollRect_Settings/Viewport/Content")).GetComponent<PageElement>().AddPage();
			GamemodesPageElement = ((Component)obj3.Find("scrollRect_Gamemodes/Viewport/Content")).GetComponent<PageElement>().AddPage();
			SelectGamemodeElement = ((Component)obj3.Find("button_SelectGamemode")).GetComponent<FunctionElement>().WithTitle("Select Gamemode").Do(OnSelectGamemodePressed);
			ExitGamemodeElement = ((Component)obj3.Find("button_ExitGamemode")).GetComponent<FunctionElement>().WithTitle("Exit Gamemode").Do(OnExitGamemodePressed);
			MenuGamemodeRounds.PopulateRounds(((Component)gamemodePage.transform.Find("page_Rounds")).gameObject);
			UpdateMenuGamemode();
			RefreshGamemodes();
		}

		private static void UpdateActionElements()
		{
			bool flag = SelectedGamemode != null && SelectedGamemode != GamemodeManager.ActiveGamemode;
			((Component)SelectGamemodeElement).gameObject.SetActive(NetworkInfo.IsHost && flag);
			if (flag)
			{
				SelectGamemodeElement.Title = "Select " + SelectedGamemode.Title;
			}
			((Component)ExitGamemodeElement).gameObject.SetActive(NetworkInfo.IsHost && GamemodeManager.ActiveGamemode != null);
			if (GamemodeManager.ActiveGamemode != null)
			{
				ExitGamemodeElement.Title = "Exit " + GamemodeManager.ActiveGamemode.Title;
			}
		}

		public static void RefreshGamemodes()
		{
			GamemodeListHelper.RefreshGamemodeList(GamemodesPageElement, delegate(Gamemode gamemode)
			{
				SelectedGamemode = gamemode;
				OverrideSettingsPage(gamemode);
				UpdateActionElements();
			});
		}
	}
	public static class MenuGamemodeRounds
	{
		private static string _shownGamemode;

		private static LevelRotation _shownRotation;

		public static MenuPage RoundsPage { get; private set; }

		public static MenuPage RoundSettingsPage { get; private set; }

		public static PageElement LevelRotationsElement { get; private set; }

		public static FunctionElement NewLevelRotationElement { get; private set; }

		public static TMP_Text SelectedLevelRotationText { get; private set; }

		public static IntElement RotationRoundsElement { get; private set; }

		public static BoolElement ShuffleLevelsElement { get; private set; }

		public static IntElement TimeBetweenRoundsElement { get; private set; }

		public static MenuPage LevelRotationSettingsPage { get; private set; }

		public static StringElement LevelRotationNameElement { get; private set; }

		public static FunctionElement DeleteRotationElement { get; private set; }

		public static PageElement LevelsElement { get; private set; }

		public static FunctionElement AddCurrentLevelElement { get; private set; }

		public static void PopulateRounds(GameObject roundsPage)
		{
			RoundsPage = roundsPage.GetComponent<MenuPage>();
			Transform obj = roundsPage.transform.Find("page_RoundSettings");
			RoundSettingsPage = ((Component)obj).GetComponent<MenuPage>();
			MenuPage roundSettingsPage = RoundSettingsPage;
			roundSettingsPage.OnShown = (Action)Delegate.Combine(roundSettingsPage.OnShown, new Action(OnRoundSettingsShown));
			Transform obj2 = obj.Find("grid_VerticalLayout");
			Transform obj3 = obj2.Find("grid_LevelRotations");
			LevelRotationsElement = ((Component)obj3.Find("scrollRect_LevelRotations/Viewport/Content")).GetComponent<PageElement>().AddPage();
			NewLevelRotationElement = ((Component)obj3.Find("button_NewLevelRotation")).GetComponent<FunctionElement>().Do(CreateNewLevelRotation);
			SelectedLevelRotationText = ((Component)obj2.Find("text_SelectedRotation")).GetComponent<TMP_Text>();
			RotationRoundsElement = ((Component)obj2.Find("button_RotationRounds")).GetComponent<IntElement>().WithTitle("Rounds Before Next Level").WithLimits(1, 10)
				.WithValue(GamemodeRoundManager.Settings.RoundsBeforeNextLevel);
			IntElement rotationRoundsElement = RotationRoundsElement;
			rotationRoundsElement.OnValueChanged = (Action<int>)Delegate.Combine(rotationRoundsElement.OnValueChanged, new Action<int>(OnRotationRoundsChanged));
			ShuffleLevelsElement = ((Component)obj2.Find("button_ShuffleLevels")).GetComponent<BoolElement>().WithTitle("Shuffle Levels").WithValue(GamemodeRoundManager.Settings.ShuffleLevels);
			BoolElement shuffleLevelsElement = ShuffleLevelsElement;
			shuffleLevelsElement.OnValueChanged = (Action<bool>)Delegate.Combine(shuffleLevelsElement.OnValueChanged, new Action<bool>(OnShuffleLevelsChanged));
			TimeBetweenRoundsElement = ((Component)obj2.Find("button_TimeBetweenRounds")).GetComponent<IntElement>().WithTitle("Time Between Rounds").WithLimits(1, 60)
				.WithValue(GamemodeRoundManager.Settings.TimeBetweenRounds);
			IntElement timeBetweenRoundsElement = TimeBetweenRoundsElement;
			timeBetweenRoundsElement.OnValueChanged = (Action<int>)Delegate.Combine(timeBetweenRoundsElement.OnValueChanged, new Action<int>(OnTimeBetweenRoundsChanged));
			Transform obj4 = roundsPage.transform.Find("page_LevelRotationSettings");
			LevelRotationSettingsPage = ((Component)obj4).GetComponent<MenuPage>();
			Transform obj5 = obj4.Find("grid_VerticalLayout");
			Transform obj6 = obj5.Find("grid_LevelRotationOptions");
			LevelRotationNameElement = ((Component)obj6.Find("button_LevelRotationName")).GetComponent<StringElement>().WithTitle("Level Rotation Name");
			StringElement levelRotationNameElement = LevelRotationNameElement;
			levelRotationNameElement.OnValueChanged = (Action<string>)Delegate.Combine(levelRotationNameElement.OnValueChanged, new Action<string>(OnLevelRotationNameChanged));
			LevelRotationNameElement.TextFormat = "{1}";
			LevelRotationNameElement.EmptyFormat = "Untitled";
			DeleteRotationElement = ((Component)obj6.Find("button_DeleteRotation")).GetComponent<FunctionElement>().Do(DeleteSelectedLevelRotation);
			LevelsElement = ((Component)obj5.Find("scrollRect_Levels/Viewport/Content")).GetComponent<PageElement>().AddPage();
			AddCurrentLevelElement = ((Component)obj5.Find("button_AddCurrentLevel")).GetComponent<FunctionElement>().WithTitle("Add Current Level").Do(AddCurrentLevel);
		}

		public static void ShowLevelRotations(string gamemodeBarcode)
		{
			_shownGamemode = gamemodeBarcode;
			RoundsPage.SelectSubPage(RoundSettingsPage);
		}

		private static void OnRoundSettingsShown()
		{
			if (!string.IsNullOrWhiteSpace(_shownGamemode))
			{
				LoadLevelRotations();
			}
		}

		public static void ShowLevelRotation(LevelRotation rotation)
		{
			_shownRotation = rotation;
			RoundsPage.SelectSubPage(LevelRotationSettingsPage);
			LevelRotationNameElement.Value = rotation.Name;
			LoadLevels();
		}

		private static void LoadLevels()
		{
			LevelsElement.Clear();
			if (_shownRotation == null)
			{
				return;
			}
			foreach (string barcode in _shownRotation.LevelBarcodes)
			{
				if (!string.IsNullOrWhiteSpace(barcode))
				{
					LevelResultElement levelResultElement = LevelsElement.AddElement<LevelResultElement>(barcode);
					levelResultElement.ApplyLevel(barcode);
					levelResultElement.OnRemovePressed = (Action)Delegate.Combine(levelResultElement.OnRemovePressed, (Action)delegate
					{
						_shownRotation.LevelBarcodes.Remove(barcode);
						LoadLevels();
					});
				}
			}
		}

		private static void LoadLevelRotations()
		{
			LevelRotationsElement.Clear();
			if (string.IsNullOrWhiteSpace(_shownGamemode))
			{
				return;
			}
			GamemodeLevelRotations rotationsByGamemode = GamemodeRoundManager.Settings.GetRotationsByGamemode(_shownGamemode);
			List<LevelRotationResultElement> elements = new List<LevelRotationResultElement>();
			foreach (LevelRotation rotation in rotationsByGamemode.LevelRotations)
			{
				LevelRotationResultElement element = LevelRotationsElement.AddElement<LevelRotationResultElement>(rotation.Name);
				elements.Add(element);
				element.LevelRotationNameText.text = (string.IsNullOrWhiteSpace(rotation.Name) ? "Untitled" : rotation.Name);
				string barcode = null;
				if (rotation.LevelBarcodes.Count > 0)
				{
					barcode = rotation.LevelBarcodes[0];
				}
				element.ApplyLevelIcon(barcode);
				element.Highlight(GamemodeRoundManager.ActiveRotation == rotation);
				LevelRotationResultElement levelRotationResultElement = element;
				levelRotationResultElement.OnSelectPressed = (Action)Delegate.Combine(levelRotationResultElement.OnSelectPressed, (Action)delegate
				{
					UnhiglightElements();
					if (GamemodeRoundManager.ActiveRotation != rotation)
					{
						GamemodeRoundManager.ActiveRotation = rotation;
						element.Highlight(highlighted: true);
					}
					else
					{
						GamemodeRoundManager.ActiveRotation = null;
					}
					UpdateSelectedText();
				});
				LevelRotationResultElement levelRotationResultElement2 = element;
				levelRotationResultElement2.OnEditPressed = (Action)Delegate.Combine(levelRotationResultElement2.OnEditPressed, (Action)delegate
				{
					ShowLevelRotation(rotation);
				});
			}
			UpdateSelectedText();
			void UnhiglightElements()
			{
				foreach (LevelRotationResultElement item in elements)
				{
					item.Highlight(highlighted: false);
				}
			}
		}

		private static void UpdateSelectedText()
		{
			LevelRotation activeRotation = GamemodeRoundManager.ActiveRotation;
			if (activeRotation == null)
			{
				SelectedLevelRotationText.text = "No Rotation Selected";
				return;
			}
			string text = (string.IsNullOrWhiteSpace(activeRotation.Name) ? "Untitled" : activeRotation.Name);
			SelectedLevelRotationText.text = text + " Selected";
		}

		private static void OnRotationRoundsChanged(int value)
		{
			GamemodeRoundManager.Settings.RoundsBeforeNextLevel = value;
			GamemodeRoundManager.SaveSettings();
		}

		private static void OnShuffleLevelsChanged(bool value)
		{
			GamemodeRoundManager.Settings.ShuffleLevels = value;
			GamemodeRoundManager.SaveSettings();
		}

		private static void OnTimeBetweenRoundsChanged(int value)
		{
			GamemodeRoundManager.Settings.TimeBetweenRounds = value;
			GamemodeRoundManager.SaveSettings();
		}

		private static void OnLevelRotationNameChanged(string value)
		{
			if (_shownRotation != null)
			{
				_shownRotation.Name = value;
				GamemodeRoundManager.SaveSettings();
			}
		}

		private static void CreateNewLevelRotation()
		{
			if (!string.IsNullOrWhiteSpace(_shownGamemode))
			{
				GamemodeLevelRotations rotationsByGamemode = GamemodeRoundManager.Settings.GetRotationsByGamemode(_shownGamemode);
				LevelRotation levelRotation = new LevelRotation();
				rotationsByGamemode.LevelRotations.Add(levelRotation);
				GamemodeRoundManager.SaveSettings();
				ShowLevelRotation(levelRotation);
			}
		}

		private static void DeleteSelectedLevelRotation()
		{
			if (_shownRotation != null && !string.IsNullOrWhiteSpace(_shownGamemode))
			{
				if (GamemodeRoundManager.ActiveRotation == _shownRotation)
				{
					GamemodeRoundManager.ActiveRotation = null;
				}
				GamemodeRoundManager.Settings.GetRotationsByGamemode(_shownGamemode).LevelRotations.Remove(_shownRotation);
				_shownRotation = null;
				GamemodeRoundManager.SaveSettings();
				ShowLevelRotations(_shownGamemode);
			}
		}

		private static void AddCurrentLevel()
		{
			if (_shownRotation != null)
			{
				string barcode = FusionSceneManager.Barcode;
				if (!string.IsNullOrWhiteSpace(barcode) && !_shownRotation.LevelBarcodes.Contains(barcode))
				{
					_shownRotation.LevelBarcodes.Add(barcode);
					LoadLevels();
				}
			}
		}
	}
}
namespace LabFusion.Menu.Data
{
	public class BoolElementData : ElementData
	{
		private bool _value;

		public Action<bool> OnValueChanged;

		public bool Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
				OnValueChanged?.Invoke(value);
			}
		}
	}
	public abstract class ElementData
	{
		public string Title { get; set; } = "Element";


		public Color Color { get; set; } = Color.white;

	}
	public static class ElementDataHelper
	{
		public static void ApplyIntData(IntElement element, IntElementData data)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			element.Title = data.Title;
			element.Color = data.Color;
			element.Increment = data.Increment;
			element.MinValue = data.MinValue;
			element.MaxValue = data.MaxValue;
			element.Value = data.Value;
			element.OnValueChanged = delegate(int v)
			{
				data.Value = v;
			};
		}

		public static void ApplyFloatData(FloatElement element, FloatElementData data)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			element.Title = data.Title;
			element.Color = data.Color;
			element.Increment = data.Increment;
			element.MinValue = data.MinValue;
			element.MaxValue = data.MaxValue;
			element.Value = data.Value;
			element.OnValueChanged = delegate(float v)
			{
				data.Value = v;
			};
		}

		public static void ApplyBoolData(BoolElement element, BoolElementData data)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			element.Title = data.Title;
			element.Color = data.Color;
			element.Value = data.Value;
			element.OnValueChanged = delegate(bool v)
			{
				data.Value = v;
			};
		}

		public static void ApplyStringData(StringElement element, StringElementData data)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			element.Title = data.Title;
			element.Color = data.Color;
			element.Value = data.Value;
			element.OnValueChanged = delegate(string v)
			{
				data.Value = v;
			};
		}

		public static void ApplyFunctionData(FunctionElement element, FunctionElementData data)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			element.Title = data.Title;
			element.Color = data.Color;
			element.OnPressed = data.OnPressed;
		}

		public static void ApplyEnumData(EnumElement element, EnumElementData data)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			element.Title = data.Title;
			element.Color = data.Color;
			element.Value = data.Value;
			element.EnumType = data.EnumType;
			element.OnValueChanged = delegate(Enum v)
			{
				data.Value = v;
			};
		}

		public static void ApplyLabelData(LabelElement element, LabelElementData data)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			element.Title = data.Title;
			element.Color = data.Color;
		}

		public static void ApplyGroupData(GroupElement group, GroupElementData data)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			group.Color = data.Color;
			foreach (ElementData element in data.Elements)
			{
				try
				{
					AddElementToGroup(group, element);
				}
				catch (Exception e)
				{
					FusionLogger.LogException("adding ElementData " + element.Title, e);
				}
			}
		}

		private static void AddElementToGroup(GroupElement group, ElementData data)
		{
			if (data is GroupElementData groupElementData)
			{
				ApplyGroupData(group.AddElement<GroupElement>(groupElementData.Title), groupElementData);
			}
			if (data is IntElementData intElementData)
			{
				ApplyIntData(group.AddElement<IntElement>(intElementData.Title), intElementData);
			}
			if (data is FloatElementData floatElementData)
			{
				ApplyFloatData(group.AddElement<FloatElement>(floatElementData.Title), floatElementData);
			}
			if (data is BoolElementData boolElementData)
			{
				ApplyBoolData(group.AddElement<BoolElement>(boolElementData.Title), boolElementData);
			}
			if (data is StringElementData stringElementData)
			{
				ApplyStringData(group.AddElement<StringElement>(stringElementData.Title), stringElementData);
			}
			if (data is FunctionElementData functionElementData)
			{
				ApplyFunctionData(group.AddElement<FunctionElement>(functionElementData.Title), functionElementData);
			}
			if (data is EnumElementData enumElementData)
			{
				ApplyEnumData(group.AddElement<EnumElement>(enumElementData.Title), enumElementData);
			}
			if (data is LabelElementData labelElementData)
			{
				ApplyLabelData(group.AddElement<LabelElement>(labelElementData.Title), labelElementData);
			}
		}
	}
	public class EnumElementData : ElementData
	{
		private Enum _value;

		public Action<Enum> OnValueChanged;

		public Enum Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
				OnValueChanged?.Invoke(value);
			}
		}

		public Type EnumType { get; set; }
	}
	public class FloatElementData : ElementData
	{
		private float _value;

		public Action<float> OnValueChanged;

		public float Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
				OnValueChanged?.Invoke(value);
			}
		}

		public float MinValue { get; set; }

		public float MaxValue { get; set; } = 1f;


		public float Increment { get; set; } = 0.01f;

	}
	public class FunctionElementData : ElementData
	{
		public Action OnPressed;
	}
	public class GroupElementData : ElementData
	{
		private List<ElementData> _elements = new List<ElementData>();

		public List<ElementData> Elements => _elements;

		public GroupElementData(string title)
		{
			base.Title = title;
		}

		public GroupElementData()
		{
		}

		public void AddElement<TElement>(TElement element) where TElement : ElementData
		{
			_elements.Add(element);
		}
	}
	public class IntElementData : ElementData
	{
		private int _value;

		public Action<int> OnValueChanged;

		public int Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
				OnValueChanged?.Invoke(value);
			}
		}

		public int MinValue { get; set; }

		public int MaxValue { get; set; } = 1;


		public int Increment { get; set; } = 1;

	}
	public class LabelElementData : ElementData
	{
	}
	public class StringElementData : ElementData
	{
		private string _value;

		public Action<string> OnValueChanged;

		public string Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
				OnValueChanged?.Invoke(value);
			}
		}
	}
}
namespace LabFusion.Math
{
	public static class BitMath
	{
		public static long MakeLong(int left, int right)
		{
			return ((long)left << 32) | (uint)right;
		}
	}
	public static class EnumConverter
	{
		private static class FuncCache<T> where T : struct, Enum
		{
			public static Func<T, int> EnumToInt32Func = CompileEnumToInt32Func<T>();

			public static Func<T, short> EnumToInt16Func = CompileEnumToInt16Func<T>();

			public static Func<T, byte> EnumToByteFunc = CompileEnumToByteFunc<T>();

			public static Func<int, T> Int32ToEnumFunc = CompileInt32ToEnumFunc<T>();

			public static Func<short, T> Int16ToEnumFunc = CompileInt16ToEnumFunc<T>();

			public static Func<byte, T> ByteToEnumFunc = CompileByteToEnumFunc<T>();
		}

		public static int ConvertToInt32<TEnum>(TEnum value) where TEnum : struct, Enum
		{
			return FuncCache<TEnum>.EnumToInt32Func(value);
		}

		public static short ConvertToInt16<TEnum>(TEnum value) where TEnum : struct, Enum
		{
			return FuncCache<TEnum>.EnumToInt16Func(value);
		}

		public static byte ConvertToByte<TEnum>(TEnum value) where TEnum : struct, Enum
		{
			return FuncCache<TEnum>.EnumToByteFunc(value);
		}

		public static TEnum ConvertToEnum<TEnum>(int value) where TEnum : struct, Enum
		{
			return FuncCache<TEnum>.Int32ToEnumFunc(value);
		}

		public static TEnum ConvertToEnum<TEnum>(short value) where TEnum : struct, Enum
		{
			return FuncCache<TEnum>.Int16ToEnumFunc(value);
		}

		public static TEnum ConvertToEnum<TEnum>(byte value) where TEnum : struct, Enum
		{
			return FuncCache<TEnum>.ByteToEnumFunc(value);
		}

		private static Func<TEnum, int> CompileEnumToInt32Func<TEnum>() where TEnum : struct, Enum
		{
			ParameterExpression parameterExpression = Expression.Parameter(typeof(TEnum));
			return Expression.Lambda<Func<TEnum, int>>(Expression.Convert(parameterExpression, typeof(int)), new ParameterExpression[1] { parameterExpression }).Compile();
		}

		private static Func<TEnum, short> CompileEnumToInt16Func<TEnum>() where TEnum : struct, Enum
		{
			ParameterExpression parameterExpression = Expression.Parameter(typeof(TEnum));
			return Expression.Lambda<Func<TEnum, short>>(Expression.Convert(parameterExpression, typeof(short)), new ParameterExpression[1] { parameterExpression }).Compile();
		}

		private static Func<TEnum, byte> CompileEnumToByteFunc<TEnum>() where TEnum : struct, Enum
		{
			ParameterExpression parameterExpression = Expression.Parameter(typeof(TEnum));
			return Expression.Lambda<Func<TEnum, byte>>(Expression.Convert(parameterExpression, typeof(byte)), new ParameterExpression[1] { parameterExpression }).Compile();
		}

		private static Func<int, TEnum> CompileInt32ToEnumFunc<TEnum>() where TEnum : struct, Enum
		{
			ParameterExpression parameterExpression = Expression.Parameter(typeof(int));
			return Expression.Lambda<Func<int, TEnum>>(Expression.Convert(parameterExpression, typeof(TEnum)), new ParameterExpression[1] { parameterExpression }).Compile();
		}

		private static Func<short, TEnum> CompileInt16ToEnumFunc<TEnum>() where TEnum : struct, Enum
		{
			ParameterExpression parameterExpression = Expression.Parameter(typeof(short));
			return Expression.Lambda<Func<short, TEnum>>(Expression.Convert(parameterExpression, typeof(TEnum)), new ParameterExpression[1] { parameterExpression }).Compile();
		}

		private static Func<byte, TEnum> CompileByteToEnumFunc<TEnum>() where TEnum : struct, Enum
		{
			ParameterExpression parameterExpression = Expression.Parameter(typeof(byte));
			return Expression.Lambda<Func<byte, TEnum>>(Expression.Convert(parameterExpression, typeof(TEnum)), new ParameterExpression[1] { parameterExpression }).Compile();
		}
	}
	internal static class ManagedMathf
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		private struct MathfInternal
		{
			public static volatile float FloatMinNormal = 1.1754944E-38f;

			public static volatile float FloatMinDenormal = float.Epsilon;

			public static bool IsFlushToZeroEnabled = FloatMinDenormal == 0f;
		}

		public static readonly float Epsilon = (MathfInternal.IsFlushToZeroEnabled ? MathfInternal.FloatMinNormal : MathfInternal.FloatMinDenormal);

		public const float Rad2Deg = 57.29578f;

		public const float Deg2Rad = (float)System.Math.PI / 180f;

		public static float Sin(float f)
		{
			return (float)System.Math.Sin(f);
		}

		public static float Acos(float f)
		{
			return (float)System.Math.Acos(f);
		}

		public static float Clamp(float value, float min, float max)
		{
			if (value < min)
			{
				value = min;
			}
			else if (value > max)
			{
				value = max;
			}
			return value;
		}

		public static int Clamp(int value, int min, int max)
		{
			if (value < min)
			{
				value = min;
			}
			else if (value > max)
			{
				value = max;
			}
			return value;
		}

		public static float Clamp01(float value)
		{
			if (value < 0f)
			{
				return 0f;
			}
			if (value > 1f)
			{
				return 1f;
			}
			return value;
		}

		public static float Lerp(float a, float b, float t)
		{
			return a + (b - a) * Clamp01(t);
		}

		public static float LerpUnclamped(float a, float b, float t)
		{
			return a + (b - a) * t;
		}

		public static int FloorToInt(float f)
		{
			return (int)System.Math.Floor(f);
		}

		public static int CeilToInt(float f)
		{
			return (int)System.Math.Ceiling(f);
		}

		public static bool Approximately(float a, float b)
		{
			return System.Math.Abs(b - a) < System.Math.Max(1E-06f * System.Math.Max(System.Math.Abs(a), System.Math.Abs(b)), Epsilon * 8f);
		}
	}
	public static class Smoothing
	{
		public static float CalculateDecay(float decay, float deltaTime)
		{
			return 1f - MathF.Exp((0f - decay) * deltaTime);
		}
	}
}
namespace LabFusion.Patching
{
	[HarmonyPatch(typeof(TimeManager))]
	public static class TimeManagerPatches
	{
		public static bool IgnorePatches { get; set; }

		[HarmonyPrefix]
		[HarmonyPatch("DECREASE_TIMESCALE")]
		public static bool DECREASE_TIMESCALE()
		{
			if (IgnorePatches)
			{
				return true;
			}
			if (!NetworkInfo.HasServer)
			{
				return true;
			}
			switch (CommonPreferences.SlowMoMode)
			{
			case TimeScaleMode.LOW_GRAVITY:
			{
				int num2 = (TimeManager.cur_timeScaleStep = Mathf.Min(TimeManager.CurrentTimeScaleStep + 1, TimeManager.max_timeScaleStep));
				TimeManager.cur_intensity = Mathf.Pow(2f, (float)num2);
				ResetTimeScale();
				return false;
			}
			case TimeScaleMode.EVERYONE:
				TimeScaleSender.SendSlowMoButton(decrease: true);
				break;
			case TimeScaleMode.HOST_ONLY:
				if (NetworkInfo.IsHost)
				{
					TimeScaleSender.SendSlowMoButton(decrease: true);
					break;
				}
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("TOGGLE_TIMESCALE")]
		public static bool TOGGLE_TIMESCALE()
		{
			if (IgnorePatches)
			{
				return true;
			}
			if (!NetworkInfo.HasServer)
			{
				return true;
			}
			switch (CommonPreferences.SlowMoMode)
			{
			case TimeScaleMode.EVERYONE:
				TimeScaleSender.SendSlowMoButton(decrease: false);
				break;
			case TimeScaleMode.HOST_ONLY:
				if (NetworkInfo.IsHost)
				{
					TimeScaleSender.SendSlowMoButton(decrease: false);
					break;
				}
				return false;
			case TimeScaleMode.LOW_GRAVITY:
				TimeManager.cur_intensity = 1f;
				ResetTimeScale();
				break;
			}
			return true;
		}

		private static void ResetTimeScale()
		{
			Time.timeScale = 1f;
			Time.fixedDeltaTime = 1f / MarrowGame.xr.Display.GetRecommendedPhysFrequency();
		}
	}
	[HarmonyPatch(typeof(Grip))]
	public static class GripPatches
	{
		public static readonly ComponentHashTable<Grip> HashTable = new ComponentHashTable<Grip>();

		private static bool HasMarrowEntity(Grip grip)
		{
			if ((Object)(object)grip._marrowEntity != (Object)null)
			{
				return true;
			}
			InteractableHost componentInParent = ((Component)grip).GetComponentInParent<InteractableHost>();
			if ((Object)(object)componentInParent != (Object)null && (Object)(object)((MarrowBehaviour)componentInParent).marrowEntity != (Object)null)
			{
				return true;
			}
			return false;
		}

		private static bool IsRuntimeCreated(Grip grip)
		{
			if ((Object)(object)((Il2CppObjectBase)grip).TryCast<WorldGrip>() != (Object)null)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch("Awake")]
		[HarmonyPrefix]
		private static void Awake(Grip __instance)
		{
			if (!HasMarrowEntity(__instance) && !IsRuntimeCreated(__instance))
			{
				int hierarchyHash = GameObjectHasher.GetHierarchyHash(((Component)__instance).gameObject);
				HashTable.AddComponent(hierarchyHash, __instance);
			}
		}

		[HarmonyPatch("OnDestroy")]
		[HarmonyPrefix]
		private static void OnDestroy(Grip __instance)
		{
			HashTable.RemoveComponent(__instance);
		}

		[HarmonyPatch("OnAttachedToHand")]
		[HarmonyPostfix]
		private static void OnAttachedToHand(Grip __instance, Hand hand)
		{
			if (!NetworkSceneManager.IsLevelNetworked || !hand.manager.IsLocalPlayer())
			{
				return;
			}
			GrabHelper.SendObjectAttach(hand, __instance);
			try
			{
				LocalPlayer.OnGrab?.Invoke(hand, __instance);
			}
			catch (Exception e)
			{
				FusionLogger.LogException("running LocalPlayer.OnGrab", e);
			}
		}

		[HarmonyPatch("OnDetachedFromHand")]
		[HarmonyPostfix]
		private static void OnDetachedFromHand(Grip __instance, Hand hand)
		{
			if (NetworkSceneManager.IsLevelNetworked)
			{
				RigManager manager = hand.manager;
				NetworkPlayer player;
				if (manager.IsLocalPlayer())
				{
					OnDetachedFromLocalPlayer(__instance, hand);
				}
				else if (NetworkPlayerManager.TryGetPlayer(manager, out player))
				{
					OnDetachedFromNetworkPlayer(__instance, hand, player);
				}
			}
		}

		private static void OnDetachedFromLocalPlayer(Grip grip, Hand hand)
		{
			GrabHelper.SendObjectDetach(hand);
			try
			{
				LocalPlayer.OnRelease?.Invoke(hand, grip);
			}
			catch (Exception e)
			{
				FusionLogger.LogException("running LocalPlayer.OnRelease", e);
			}
		}

		private static void OnDetachedFromNetworkPlayer(Grip grip, Hand hand, NetworkPlayer networkPlayer)
		{
			try
			{
				networkPlayer.Grabber.CheckDetachAndReattach(hand, grip);
			}
			catch (Exception e)
			{
				FusionLogger.LogException("running RigGrabber.CheckDetachAndReattach", e);
			}
		}
	}
	[HarmonyPatch(typeof(ArtRig))]
	public static class ArtRigPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("ArtOutputUpdate")]
		public static void ArtOutputUpdate(ArtRig __instance, PhysicsRig inRig)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkInfo.HasServer)
			{
				float num = 0f;
				if (NetworkPlayerManager.TryGetPlayer(((Rig)inRig).manager, out var player))
				{
					num = player.JawFlapper.GetAngle();
				}
				((Rig)inRig).m_jaw.localRotation = Quaternion.AngleAxis(num, Vector3Extensions.right);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("ArtOutputLateUpdate")]
		public static void ArtOutputLateUpdate(ArtRig __instance, PhysicsRig inRig)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkInfo.HasServer)
			{
				Transform boneTransform = ((Rig)inRig).manager._avatar.animator.GetBoneTransform((HumanBodyBones)23);
				if ((Object)(object)boneTransform != (Object)null)
				{
					boneTransform.rotation = __instance.artJaw.rotation;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("ApplyRotationOffsetsToRig")]
		public static void ApplyRotationOffsetsToRig(ArtRig __instance, Avatar avatar)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			__instance.artJaw.localRotation = avatar.artOffsets.jawOffset;
		}

		[HarmonyPostfix]
		[HarmonyPatch("SetArtOutputAvatar")]
		public static void SetArtOutputAvatar(ArtRig __instance, PhysicsRig inRig, Avatar avatar)
		{
			try
			{
				DelayUtilities.InvokeDelayed(delegate
				{
					Internal_WaitForBarcode(((Rig)inRig).manager, avatar);
				}, 2);
			}
			catch (Exception e)
			{
				FusionLogger.LogException("ArtRig.SetAvatar", e);
			}
		}

		private static void Internal_WaitForBarcode(RigManager __instance, Avatar newAvatar)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance._avatar != (Object)(object)newAvatar))
			{
				NetworkPlayer player;
				if (__instance.IsLocalPlayer())
				{
					LocalAvatar.InvokeAvatarChanged(newAvatar, ((ScannableReference)__instance.AvatarCrate).Barcode.ID);
				}
				else if (NetworkPlayerManager.TryGetPlayer(__instance, out player))
				{
					player.Internal_OnAvatarChanged(((ScannableReference)__instance.AvatarCrate).Barcode.ID);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Avatar))]
	public static class AvatarPatches
	{
		public static bool IgnorePatches;

		[HarmonyPatch("RefreshBodyMeasurements")]
		[HarmonyPatch(new Type[] { })]
		[HarmonyPostfix]
		public static void RefreshBodyMeasurementsPostfix(Avatar __instance)
		{
			if (!IgnorePatches)
			{
				OverrideBodyMeasurements(__instance);
			}
		}

		private static bool ValidateAvatar(Avatar avatar, out NetworkPlayer player, out RigManager rm)
		{
			rm = ((Component)avatar).GetComponentInParent<RigManager>();
			player = null;
			if ((Object)(object)rm != (Object)null && NetworkPlayerManager.TryGetPlayer(rm, out player) && !Object.op_Implicit((Object)(object)((Il2CppObjectBase)avatar).TryCast<RealHeptaAvatar>()))
			{
				return player.AvatarSetter.AvatarStats != null;
			}
			return false;
		}

		private static void OverrideBodyMeasurements(Avatar __instance)
		{
			try
			{
				if (NetworkInfo.HasServer && ValidateAvatar(__instance, out var player, out var _))
				{
					player.AvatarSetter.AvatarStats.CopyTo(__instance);
				}
			}
			catch (Exception e)
			{
				FusionLogger.LogException("patching Avatar.RefreshBodyMeasurements", e);
			}
		}
	}
	[HarmonyPatch(typeof(OpenController))]
	public static class OpenControllerPatches
	{
		private static bool LockedMovement(OpenController __instance)
		{
			if (((Rig)((BaseController)__instance).contRig).manager.IsLocalPlayer() && LocalControls.LockedMovement)
			{
				return true;
			}
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch("OnUpdate")]
		public static void OnUpdate(OpenController __instance)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (LockedMovement(__instance))
			{
				((BaseController)__instance)._thumbstickAxis = Vector2.zero;
				((BaseController)__instance)._aButton = false;
				((BaseController)__instance)._aButtonUp = false;
			}
		}
	}
	[HarmonyPatch(typeof(XRHMD))]
	public static class XRHMDPatches
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		public static void IsUserPresent(ref bool __result)
		{
			if (NetworkInfo.HasServer)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch(typeof(OpenControllerRig))]
	public static class OpenControllerRigPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnBeginCameraRendering")]
		public static bool OnBeginCameraRendering(OpenControllerRig __instance, ScriptableRenderContext ctx, Camera cam)
		{
			if (NetworkPlayerManager.HasExternalPlayer(((Rig)__instance).manager))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(OpenControllerRig), "OnEarlyUpdate")]
	public static class OpenEarlyUpdatePatch
	{
		public static void Prefix(OpenControllerRig __instance, ref Action<bool> __state)
		{
			__state = OpenControllerRig.OnPauseStateChange;
			if (!((Rig)__instance).manager.IsLocalPlayer())
			{
				OpenControllerRig.OnPauseStateChange = null;
			}
		}

		public static void Postfix(ref Action<bool> __state)
		{
			OpenControllerRig.OnPauseStateChange = __state;
		}
	}
	[HarmonyPatch(typeof(OpenControllerRig), "OnRealHeptaEarlyUpdate")]
	public static class OpenRealHeptaEarlyUpdatePatch
	{
		public static void Prefix(OpenControllerRig __instance, float deltaTime)
		{
			if (NetworkPlayerManager.TryGetPlayer(((Rig)__instance).manager, out var player) && !player.NetworkEntity.IsOwner)
			{
				player.OnOverrideControllerRig();
			}
		}
	}
	[HarmonyPatch(typeof(PhysicsRig))]
	public static class PhysicsRigPatches
	{
		public static bool ForceAllowUnragdoll { get; set; }

		[HarmonyPostfix]
		[HarmonyPatch("SetAvatar")]
		public static void SetAvatarPostfix(PhysicsRig __instance, Avatar avatar)
		{
			if (!NetworkInfo.HasServer || __instance._impactProperties == null)
			{
				return;
			}
			foreach (ImpactProperties item in (Il2CppArrayBase<ImpactProperties>)(object)__instance._impactProperties)
			{
				item._cachedSurfaceData = item.surfaceData;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("RagdollRig")]
		public static void RagdollRig(PhysicsRig __instance)
		{
			if (NetworkSceneManager.IsLevelNetworked && ((Rig)__instance).manager.IsLocalPlayer())
			{
				MessageRelay.RelayNative(PhysicsRigStateData.Create(PhysicsRigStateType.RAGDOLL, enabled: true), NativeMessageTag.PhysicsRigState, CommonMessageRoutes.ReliableToOtherClients);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("UnRagdollRig")]
		public static bool UnRagdollRig(PhysicsRig __instance)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if (((Rig)__instance).manager.IsLocalPlayer())
			{
				if (!ForceAllowUnragdoll && LocalRagdoll.RagdollLocked)
				{
					return false;
				}
				MessageRelay.RelayNative(PhysicsRigStateData.Create(PhysicsRigStateType.RAGDOLL, enabled: false), NativeMessageTag.PhysicsRigState, CommonMessageRoutes.ReliableToOtherClients);
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("ShutdownRig")]
		public static void ShutdownRig(PhysicsRig __instance)
		{
			if (NetworkSceneManager.IsLevelNetworked && ((Rig)__instance).manager.IsLocalPlayer())
			{
				MessageRelay.RelayNative(PhysicsRigStateData.Create(PhysicsRigStateType.SHUTDOWN, enabled: true), NativeMessageTag.PhysicsRigState, CommonMessageRoutes.ReliableToOtherClients);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("TurnOnRig")]
		public static bool TurnOnRig(PhysicsRig __instance)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if (!((Rig)__instance).manager.IsLocalPlayer())
			{
				return true;
			}
			if (!ForceAllowUnragdoll && LocalRagdoll.RagdollLocked)
			{
				return false;
			}
			MessageRelay.RelayNative(PhysicsRigStateData.Create(PhysicsRigStateType.SHUTDOWN, enabled: false), NativeMessageTag.PhysicsRigState, CommonMessageRoutes.ReliableToOtherClients);
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("PhysicalLegs")]
		public static void PhysicalLegs(PhysicsRig __instance)
		{
			if (NetworkSceneManager.IsLevelNetworked && ((Rig)__instance).manager.IsLocalPlayer())
			{
				MessageRelay.RelayNative(PhysicsRigStateData.Create(PhysicsRigStateType.PHYSICAL_LEGS, enabled: true), NativeMessageTag.PhysicsRigState, CommonMessageRoutes.ReliableToOtherClients);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("KinematicLegs")]
		public static void KinematicLegs(PhysicsRig __instance)
		{
			if (NetworkSceneManager.IsLevelNetworked && ((Rig)__instance).manager.IsLocalPlayer())
			{
				MessageRelay.RelayNative(PhysicsRigStateData.Create(PhysicsRigStateType.PHYSICAL_LEGS, enabled: false), NativeMessageTag.PhysicsRigState, CommonMessageRoutes.ReliableToOtherClients);
			}
		}
	}
	[HarmonyPatch(typeof(PhysLimb))]
	public static class PhysLimbPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("ShutdownLimb")]
		public static void ShutdownLimb(PhysLimb __instance)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return;
			}
			NetworkEntity networkEntity = PhysLimbExtender.Cache.Get(__instance);
			if (networkEntity != null && networkEntity.IsOwner)
			{
				NetworkPlayer extender = networkEntity.GetExtender<NetworkPlayer>();
				if (extender != null)
				{
					PhysicsRig physicsRig = extender.RigRefs.RigManager.physicsRig;
					bool left = (Object)(object)__instance == (Object)(object)physicsRig.legLf;
					MessageRelay.RelayNative(PhysicsRigStateData.Create(PhysicsRigStateType.LEG_SHUTDOWN, enabled: true, left), NativeMessageTag.PhysicsRigState, CommonMessageRoutes.ReliableToOtherClients);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerDamageReceiver))]
	public static class PlayerDamageReceiverPatches
	{
		[HarmonyPatch("ReceiveAttack")]
		[HarmonyPrefix]
		public static bool ReceiveAttack(PlayerDamageReceiver __instance, ref Attack attack)
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkInfo.HasServer)
			{
				return true;
			}
			RigManager rigManager = __instance.health._rigManager;
			TriggerRefProxy proxy = attack.proxy;
			RigManager val = null;
			if ((Object)(object)proxy != (Object)null && (Object)(object)proxy.root != (Object)null)
			{
				val = RigManager.Cache.Get(proxy.root);
			}
			if ((Object)(object)rigManager != (Object)null && (Object)(object)val != (Object)null)
			{
				NetworkPlayer player2;
				if (rigManager.IsLocalPlayer())
				{
					if (NetworkPlayerManager.TryGetPlayer(val, out var player) && !player.NetworkEntity.IsOwner)
					{
						FusionPlayer.LastAttacker = player.PlayerID;
						attack.damage = 0f;
						return true;
					}
					FusionPlayer.LastAttacker = null;
				}
				else if (NetworkPlayerManager.TryGetPlayer(rigManager, out player2) && val.IsLocalPlayer())
				{
					if (!NetworkCombatManager.CanAttack(player2))
					{
						return false;
					}
					PlayerSender.SendPlayerDamage(player2.PlayerID, attack, __instance.bodyPart);
					PlayerSender.SendPlayerAction(PlayerActionType.DEALT_DAMAGE_TO_OTHER_PLAYER, player2.PlayerID);
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(HeadSFX))]
	public static class HeadSFXPatches
	{
		[HarmonyPatch("RecoveryVocal")]
		[HarmonyPrefix]
		public static void RecoveryVocal(HeadSFX __instance)
		{
			RigManager manager = ((Rig)__instance._physRig).manager;
			if (NetworkInfo.HasServer && manager.IsLocalPlayer())
			{
				PlayerSender.SendPlayerAction(PlayerActionType.RECOVERY);
			}
		}

		[HarmonyPatch("DyingVocal")]
		[HarmonyPrefix]
		public static void DyingVocal(HeadSFX __instance)
		{
			if (NetworkInfo.HasServer && ((Rig)__instance._physRig).manager.IsLocalPlayer())
			{
				if (LocalPlayer.RagdollOnDeath)
				{
					LocalRagdoll.ToggleRagdoll(ragdolled: true);
				}
				if (FusionPlayer.LastAttacker.HasValue)
				{
					PlayerSender.SendPlayerAction(PlayerActionType.DYING_BY_OTHER_PLAYER, FusionPlayer.LastAttacker.Value);
				}
				PlayerSender.SendPlayerAction(PlayerActionType.DYING);
			}
		}

		[HarmonyPatch("DeathVocal")]
		[HarmonyPrefix]
		public static void DeathVocal(HeadSFX __instance)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkInfo.HasServer)
			{
				return;
			}
			RigManager manager = ((Rig)__instance._physRig).manager;
			if (manager.IsLocalPlayer() && !manager.health.alive)
			{
				if (GamemodeManager.IsGamemodeStarted && GamemodeManager.ActiveGamemode.AutoHolsterOnDeath)
				{
					manager.physicsRig.leftHand.TryAutoHolsterGrip(RigData.Refs);
					manager.physicsRig.rightHand.TryAutoHolsterGrip(RigData.Refs);
				}
				if (FusionPlayer.TryGetSpawnPoint(out var point))
				{
					manager.checkpointPosition = point.position;
					manager.checkpointFwd = point.forward;
				}
				PlayerSender.SendPlayerAction(PlayerActionType.DEATH);
				if (FusionPlayer.LastAttacker.HasValue)
				{
					PlayerSender.SendPlayerAction(PlayerActionType.DEATH_BY_OTHER_PLAYER, FusionPlayer.LastAttacker.Value);
				}
				LocalPlayer.ClearConstraints();
			}
		}
	}
	[HarmonyPatch(typeof(Health))]
	public static class HealthPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("Respawn")]
		public static void Respawn(Health __instance)
		{
			if (!__instance._rigManager.IsLocalPlayer())
			{
				return;
			}
			LocalHealth.InvokeRespawn();
			if (NetworkInfo.HasServer)
			{
				PlayerSender.SendPlayerAction(PlayerActionType.RESPAWN);
				LocalPlayer.ClearConstraints();
				if (LocalPlayer.RagdollOnDeath)
				{
					LocalRagdoll.ToggleRagdoll(ragdolled: false);
					LocalPlayer.TeleportToCheckpoint();
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player_Health))]
	public static class PlayerHealthPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("ApplyKillDamage")]
		public static void ApplyKillDamagePostfix(Player_Health __instance)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			if (NetworkInfo.HasServer && ((Health)__instance)._rigManager.IsLocalPlayer() && (int)((Health)__instance).healthMode != 1)
			{
				LocalPlayer.TeleportToCheckpoint();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("Dying")]
		public static void Dying(Player_Health __instance)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkInfo.HasServer && ((Health)__instance)._rigManager.IsLocalPlayer() && CommonPreferences.Knockout && CommonPreferences.Mortality && (int)((Health)__instance).healthMode == 0 && !LocalHealth.MortalityOverride.HasValue)
			{
				LocalRagdoll.Knockout(LobbyInfoManager.LobbyInfo.KnockoutLength);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("LifeSavingDamgeDealt")]
		public static void LifeSavingDamgeDealt(Player_Health __instance)
		{
			if (((Health)__instance)._rigManager.IsLocalPlayer() && LocalPlayer.RagdollOnDeath)
			{
				LocalRagdoll.ToggleRagdoll(ragdolled: false);
			}
		}
	}
	[HarmonyPatch(typeof(PowerPuncher))]
	public static class PowerPuncherPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("OnSignificantCollisionEnter")]
		public static void OnSignificantCollisionEnter(PowerPuncher __instance, RelevantCollision collision)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkInfo.HasServer || !Mathf.Approximately(__instance._cooldownStartTime, Time.time))
			{
				return;
			}
			Rigidbody rigidbody = collision.rigidbody;
			if ((Object)(object)rigidbody == (Object)null)
			{
				return;
			}
			MarrowBody val = MarrowBody.Cache.Get(((Component)rigidbody).gameObject);
			if (!((Object)(object)val == (Object)null))
			{
				NetworkEntity networkEntity = IMarrowEntityExtender.Cache.Get(val.Entity);
				if (networkEntity != null && networkEntity.GetExtender<NetworkPlayer>() != null && networkEntity.IsOwner)
				{
					Vector3 val2 = __instance._host.Rb.velocity - val._rigidbody.velocity;
					LocalRagdoll.Knockout(Mathf.Clamp(((Vector3)(ref val2)).magnitude, 0f, 2f));
				}
			}
		}
	}
	[HarmonyPatch(typeof(Seat))]
	public static class SeatPatches
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass6_0
		{
			public bool isAwaiting;

			internal void <Internal_SyncSeat>b__0(NetworkEntity p)
			{
				isAwaiting = false;
			}
		}

		[CompilerGenerated]
		private sealed class <Internal_SyncSeat>d__6 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Seat __instance;

			private <>c__DisplayClass6_0 <>8__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Internal_SyncSeat>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					MarrowBody val = MarrowBody.Cache.Get(((Component)__instance.seatRb).gameObject);
					if ((Object)(object)val == (Object)null)
					{
						return false;
					}
					if (!SeatExtender.Cache.ContainsSource(__instance))
					{
						<>8__1 = new <>c__DisplayClass6_0();
						<>8__1.isAwaiting = true;
						PropSender.SendPropCreation(val.Entity, delegate
						{
							<>8__1.isAwaiting = false;
						});
						goto IL_00a7;
					}
					goto IL_00bb;
				}
				case 1:
					<>1__state = -1;
					goto IL_00a7;
				case 2:
					{
						<>1__state = -1;
						if (!__instance.rigManager.IsLocalPlayer())
						{
							return false;
						}
						NetworkEntity networkEntity = SeatExtender.Cache.Get(__instance);
						if (networkEntity == null)
						{
							return false;
						}
						SeatExtender extender = networkEntity.GetExtender<SeatExtender>();
						MessageRelay.RelayNative(new PlayerRepSeatData
						{
							SeatID = networkEntity.ID,
							SeatIndex = (byte)extender.GetIndex(__instance).Value,
							IsIngress = true
						}, NativeMessageTag.PlayerRepSeat, CommonMessageRoutes.ReliableToOtherClients);
						return false;
					}
					IL_00a7:
					if (<>8__1.isAwaiting)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>8__1 = null;
					goto IL_00bb;
					IL_00bb:
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static bool IgnorePatches { get; set; }

		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerStay")]
		public static bool OnTriggerStay(Collider other)
		{
			if (!NetworkInfo.HasServer)
			{
				return true;
			}
			PhysGrounder component = ((Component)other).GetComponent<PhysGrounder>();
			if ((Object)(object)component != (Object)null && NetworkPlayerManager.HasExternalPlayer(((Rig)component.physRig).manager))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("Register")]
		public static bool Register(Seat __instance, RigManager rM)
		{
			if (IgnorePatches)
			{
				IgnorePatches = false;
				return true;
			}
			if (!NetworkInfo.HasServer)
			{
				return true;
			}
			if (rM.IsLocalPlayer())
			{
				MelonCoroutines.Start(Internal_SyncSeat(__instance));
			}
			else if (NetworkPlayerManager.HasExternalPlayer(rM))
			{
				return false;
			}
			return true;
		}

		[IteratorStateMachine(typeof(<Internal_SyncSeat>d__6))]
		private static IEnumerator Internal_SyncSeat(Seat __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Internal_SyncSeat>d__6(0)
			{
				__instance = __instance
			};
		}

		[HarmonyPrefix]
		[HarmonyPatch("DeRegister")]
		public static void DeRegister(Seat __instance)
		{
			if (IgnorePatches)
			{
				IgnorePatches = false;
			}
			else if (NetworkInfo.HasServer && __instance._rig.IsLocalPlayer())
			{
				NetworkEntity networkEntity = SeatExtender.Cache.Get(__instance);
				if (networkEntity != null)
				{
					SeatExtender extender = networkEntity.GetExtender<SeatExtender>();
					MessageRelay.RelayNative(new PlayerRepSeatData
					{
						SeatID = networkEntity.ID,
						SeatIndex = (byte)extender.GetIndex(__instance).Value,
						IsIngress = false
					}, NativeMessageTag.PlayerRepSeat, CommonMessageRoutes.ReliableToOtherClients);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Mirror))]
	public static class MirrorPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("WriteTransforms")]
		public static void WriteTransforms(Mirror __instance)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkInfo.HasServer)
			{
				return;
			}
			Transform boneTransform = __instance.rigManager.avatar.animator.GetBoneTransform((HumanBodyBones)23);
			if (!((Object)(object)boneTransform == (Object)null))
			{
				Transform boneTransform2 = __instance.Reflection.animator.GetBoneTransform((HumanBodyBones)23);
				if (!((Object)(object)boneTransform2 == (Object)null))
				{
					boneTransform2.localRotation = boneTransform.localRotation;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerEnter")]
		public static bool OnTriggerEnter(Mirror __instance, Collider c)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Rigidbody attachedRigidbody = c.attachedRigidbody;
			if (!Object.op_Implicit((Object)(object)attachedRigidbody))
			{
				return true;
			}
			TriggerRefProxy component = ((Component)attachedRigidbody).GetComponent<TriggerRefProxy>();
			if (!Object.op_Implicit((Object)(object)component) || (int)component.triggerType != 0)
			{
				return true;
			}
			if (NetworkInfo.HasServer)
			{
				return OnEnterMultiplayer(__instance, component);
			}
			return OnEnterSingleplayer(__instance, component);
		}

		private static bool OnEnterSingleplayer(Mirror __instance, TriggerRefProxy proxy)
		{
			RigManager rigManager = RigManager.Cache.Get(proxy.root);
			foreach (PointItem loadedItem in PointItemManager.LoadedItems)
			{
				if (loadedItem.IsEquipped)
				{
					loadedItem.OnUpdateObjects(new PointItemPayload
					{
						type = PointItemPayloadType.MIRROR,
						rigManager = rigManager,
						mirror = __instance,
						playerId = PlayerIDManager.LocalID
					}, isVisible: true);
				}
			}
			return true;
		}

		private static bool OnEnterMultiplayer(Mirror __instance, TriggerRefProxy proxy)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			RigManager val = null;
			MirrorIdentifier component = ((Component)__instance).GetComponent<MirrorIdentifier>();
			PlayerID playerID;
			if ((Object)(object)component != (Object)null)
			{
				playerID = PlayerIDManager.GetPlayerID(component.id);
				if (playerID != null && PlayerRepUtilities.TryGetReferences(playerID, out var references))
				{
					val = references.RigManager;
				}
			}
			else
			{
				if (!NetworkPlayerManager.TryGetPlayer(RigManager.Cache.Get(proxy.root), out var player))
				{
					return true;
				}
				byte smallID = player.PlayerID.SmallID;
				component = ((Component)__instance).gameObject.AddComponent<MirrorIdentifier>();
				byte b = (component.id = PlayerIDManager.LocalSmallID);
				Transform transform = new GameObject("Fusion Mirror Root").transform;
				((Component)transform).gameObject.SetActive(false);
				((Component)transform).transform.parent = ((Component)__instance).transform.parent;
				((Component)transform).gameObject.AddComponent<DestroyOnDisconnect>();
				for (byte b2 = 0; b2 < 5; b2++)
				{
					if (b2 == b)
					{
						b2++;
					}
					Transform transform2 = new GameObject($"Mirror {b2}").transform;
					transform2.parent = transform;
					GameObject obj = Object.Instantiate<GameObject>(((Component)__instance).gameObject, transform2, true);
					((Object)obj).name = ((Object)((Component)__instance).gameObject).name;
					obj.GetComponent<MirrorIdentifier>().id = b2;
					Mirror component2 = obj.GetComponent<Mirror>();
					GameObject val2 = Object.Instantiate<GameObject>(((Component)component2._reflectTran).gameObject, transform2, true);
					((Object)val2.gameObject).name = ((Object)__instance._reflectTran).name;
					component2._reflectTran = val2.transform;
					component2._avatarsTran = val2.transform.Find("AVATARS");
				}
				((Component)transform).gameObject.SetActive(true);
				if (component.id != smallID)
				{
					return false;
				}
				playerID = PlayerIDManager.GetPlayerID(component.id);
				if (playerID != null && PlayerRepUtilities.TryGetReferences(playerID, out var references2))
				{
					val = references2.RigManager;
				}
			}
			if ((Object)(object)val == (Object)null || playerID == null)
			{
				return false;
			}
			bool flag = TriggerUtilities.IsMatchingRig(proxy, val);
			if (flag)
			{
				foreach (PointItem loadedItem in PointItemManager.LoadedItems)
				{
					if (playerID.HasEquipped(loadedItem))
					{
						loadedItem.OnUpdateObjects(new PointItemPayload
						{
							type = PointItemPayloadType.MIRROR,
							rigManager = val,
							mirror = __instance,
							playerId = playerID
						}, isVisible: true);
					}
				}
			}
			return flag;
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerExit")]
		public static bool OnTriggerExit(Mirror __instance, Collider c)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Rigidbody attachedRigidbody = c.attachedRigidbody;
			if (!Object.op_Implicit((Object)(object)attachedRigidbody))
			{
				return true;
			}
			TriggerRefProxy component = ((Component)attachedRigidbody).GetComponent<TriggerRefProxy>();
			if (!Object.op_Implicit((Object)(object)component) || (int)component.triggerType != 0)
			{
				return true;
			}
			if (NetworkInfo.HasServer)
			{
				return OnExitMultiplayer(__instance, component);
			}
			return OnExitSingleplayer(__instance, component);
		}

		private static bool OnExitMultiplayer(Mirror __instance, TriggerRefProxy proxy)
		{
			RigManager val = null;
			PlayerID playerID = null;
			MirrorIdentifier component = ((Component)__instance).GetComponent<MirrorIdentifier>();
			if ((Object)(object)component != (Object)null)
			{
				playerID = PlayerIDManager.GetPlayerID(component.id);
				if (playerID != null && PlayerRepUtilities.TryGetReferences(playerID, out var references))
				{
					val = references.RigManager;
				}
			}
			if ((Object)(object)val == (Object)null || playerID == null)
			{
				return false;
			}
			bool flag = TriggerUtilities.IsMatchingRig(proxy, val);
			if (flag)
			{
				foreach (PointItem loadedItem in PointItemManager.LoadedItems)
				{
					if (playerID.EquippedItems.Contains(loadedItem.Barcode))
					{
						loadedItem.OnUpdateObjects(new PointItemPayload
						{
							type = PointItemPayloadType.MIRROR,
							rigManager = val,
							mirror = __instance,
							playerId = playerID
						}, isVisible: false);
					}
				}
			}
			return flag;
		}

		private static bool OnExitSingleplayer(Mirror __instance, TriggerRefProxy proxy)
		{
			RigManager rigManager = RigManager.Cache.Get(proxy.root);
			foreach (PointItem loadedItem in PointItemManager.LoadedItems)
			{
				if (loadedItem.IsEquipped)
				{
					loadedItem.OnUpdateObjects(new PointItemPayload
					{
						type = PointItemPayloadType.MIRROR,
						rigManager = rigManager,
						mirror = __instance,
						playerId = PlayerIDManager.LocalID
					}, isVisible: false);
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ZoneCuller))]
	public static class ZoneCullerPatches
	{
		public static readonly Dictionary<int, ZoneCuller> CullerIdToZone = new Dictionary<int, ZoneCuller>();

		public static readonly Dictionary<int, ZoneCuller> HashToZone = new Dictionary<int, ZoneCuller>();

		public static readonly Dictionary<ZoneCuller, int> ZoneToHash = new Dictionary<ZoneCuller, int>((IEqualityComparer<ZoneCuller>?)new UnityComparer());

		[HarmonyPrefix]
		[HarmonyPatch("OnEnable")]
		public static void OnEnable(ZoneCuller __instance)
		{
			if (__instance._hasZoneId)
			{
				int fastHash = GameObjectHasher.GetFastHash(((Component)__instance).gameObject);
				if (HashToZone.TryGetValue(fastHash, out var value))
				{
					FusionLogger.Warn($"Zones {((Object)__instance).name} and {((Object)value).name} have a conflicting hash of {fastHash}!");
				}
				else
				{
					CullerIdToZone.Add(__instance._zoneId, __instance);
					HashToZone.Add(fastHash, __instance);
					ZoneToHash.Add(__instance, fastHash);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnDisable")]
		public static void OnDisable(ZoneCuller __instance)
		{
			CullerIdToZone.Remove(__instance._zoneId);
			if (ZoneToHash.TryGetValue(__instance, out var value))
			{
				ZoneToHash.Remove(__instance);
				HashToZone.Remove(value);
			}
		}
	}
	[HarmonyPatch(typeof(ZoneCullManager))]
	public static class ZoneCullManagerPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("Register")]
		[HarmonyPatch(new Type[]
		{
			typeof(int),
			typeof(MarrowEntity)
		})]
		public static void Register(int cullerId, MarrowEntity entity)
		{
			if (NetworkInfo.HasServer)
			{
				NetworkEntity networkEntity = IMarrowEntityExtender.Cache.Get(entity);
				if (networkEntity != null && networkEntity.IsOwner)
				{
					MessageRelay.RelayNative(new NetworkEntityReference(networkEntity.ID), NativeMessageTag.EntityZoneRegister, CommonMessageRoutes.ReliableToOtherClients);
				}
			}
		}
	}
}
namespace LabFusion.Grabbables
{
	public static class GrabHelper
	{
		public static void SendObjectForcePull(Hand hand, Grip grip)
		{
			if (NetworkInfo.HasServer)
			{
				Internal_ObjectForcePull(hand, grip);
			}
		}

		internal static void Internal_ObjectForcePull(Hand hand, Grip grip)
		{
			if (!NetworkInfo.HasServer)
			{
				return;
			}
			MarrowEntity marrowEntity = grip._marrowEntity;
			if ((Object)(object)marrowEntity == (Object)null || Object.op_Implicit((Object)(object)((Component)grip).GetComponentInParent<RigManager>()))
			{
				return;
			}
			_ = PlayerIDManager.LocalSmallID;
			if (GripExtender.Cache.TryGet(grip, out var value))
			{
				value.HookOnRegistered(delegate(NetworkEntity entity)
				{
					NetworkEntityManager.TakeOwnership(entity);
				});
			}
			else
			{
				PropSender.SendPropCreation(marrowEntity);
			}
		}

		public static void SendObjectAttach(Hand hand, Grip grip, PlayerID target = null)
		{
			if (NetworkInfo.HasServer)
			{
				Internal_ObjectAttach(hand, grip, target);
			}
		}

		internal static void Internal_ObjectAttach(Hand hand, Grip grip, PlayerID target = null)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkInfo.HasServer)
			{
				return;
			}
			Handedness handedness = hand.handedness;
			byte localSmallID = PlayerIDManager.LocalSmallID;
			GrabGroup group = GrabGroup.UNKNOWN;
			SerializedGrab serializedGrab = null;
			if ((Object)(object)grip == (Object)null)
			{
				return;
			}
			if (((HandReciever)grip).IsStatic)
			{
				if ((Object)(object)((Il2CppObjectBase)grip).TryCast<WorldGrip>() != (Object)null)
				{
					group = GrabGroup.WORLD;
					serializedGrab = new SerializedWorldGrab(localSmallID);
					OnFinish();
					return;
				}
				group = GrabGroup.STATIC;
				ComponentHashData dataFromComponent = GripPatches.HashTable.GetDataFromComponent(grip);
				if (dataFromComponent != null)
				{
					serializedGrab = new SerializedStaticGrab(dataFromComponent);
					OnFinish();
				}
			}
			else
			{
				if (!((HandReciever)grip).HasRigidbody)
				{
					return;
				}
				group = GrabGroup.ENTITY;
				MarrowEntity marrowEntity = grip._marrowEntity;
				if ((Object)(object)marrowEntity == (Object)null)
				{
					return;
				}
				if (GripExtender.Cache.TryGet(grip, out var value))
				{
					value.HookOnRegistered(delegate(NetworkEntity entity)
					{
						GripExtender extender3 = entity.GetExtender<GripExtender>();
						serializedGrab = new SerializedEntityGrab(extender3.GetIndex(grip).Value, entity.ID);
						OnFinish();
					});
					return;
				}
				PropSender.SendPropCreation(marrowEntity, delegate(NetworkEntity networkEntity)
				{
					NetworkProp extender2 = networkEntity.GetExtender<NetworkProp>();
					if (extender2 != null)
					{
						OnEntityFinish(extender2);
					}
				});
			}
			void OnEntityFinish(NetworkProp prop)
			{
				GripExtender extender = prop.NetworkEntity.GetExtender<GripExtender>();
				serializedGrab = new SerializedEntityGrab(extender.GetIndex(grip).Value, prop.NetworkEntity.ID);
				OnFinish();
			}
			void OnFinish()
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				serializedGrab.WriteDefaultGrip(hand, grip);
				PlayerRepGrabData data = new PlayerRepGrabData
				{
					Handedness = handedness,
					Group = group,
					SerializedGrab = serializedGrab
				};
				if (target == null)
				{
					MessageRelay.RelayNative(data, NativeMessageTag.PlayerRepGrab, CommonMessageRoutes.ReliableToOtherClients);
				}
				else
				{
					MessageRelay.RelayNative(data, NativeMessageTag.PlayerRepGrab, new MessageRoute(target.SmallID, NetworkChannel.Reliable));
				}
			}
		}

		public static void SendObjectDetach(Hand hand)
		{
			Internal_ObjectDetach(hand);
		}

		internal static void Internal_ObjectDetach(Hand hand)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Handedness handedness = hand.handedness;
			if (!((Object)(object)hand.m_CurrentAttachedGO != (Object)null) && NetworkInfo.HasServer)
			{
				MessageRelay.RelayNative(new PlayerRepReleaseData
				{
					Handedness = handedness
				}, NativeMessageTag.PlayerRepRelease, CommonMessageRoutes.ReliableToOtherClients);
			}
		}
	}
	public enum GrabGroup : byte
	{
		UNKNOWN,
		ENTITY,
		STATIC,
		WORLD
	}
	public abstract class GrabGroupHandler<T> : GrabGroupHandler where T : SerializedGrab, new()
	{
		public override void HandleGrab(ref SerializedGrab serializedGrab, INetSerializer serializer)
		{
			T value = serializedGrab as T;
			NetSerializerExtensions.SerializeValue(serializer, ref value);
			serializedGrab = value;
		}
	}
	public abstract class GrabGroupHandler
	{
		public static readonly GrabGroupHandler[] Handlers = new GrabGroupHandler[255];

		public virtual GrabGroup? Group { get; }

		public abstract void HandleGrab(ref SerializedGrab serializedGrab, INetSerializer serializer);

		public static void RegisterHandlersFromAssembly(Assembly targetAssembly)
		{
			if (targetAssembly == null)
			{
				throw new NullReferenceException("Can't register from a null assembly!");
			}
			AssemblyUtilities.LoadAllValid<GrabGroupHandler>(targetAssembly, RegisterHandler);
		}

		public static void RegisterHandler<T>() where T : NativeMessageHandler
		{
			RegisterHandler(typeof(T));
		}

		protected static void RegisterHandler(Type type)
		{
			GrabGroupHandler grabGroupHandler = Activator.CreateInstance(type) as GrabGroupHandler;
			if (!grabGroupHandler.Group.HasValue)
			{
				FusionLogger.Warn("Didn't register " + type.Name + " because its grab group was null!");
				return;
			}
			byte value = (byte)grabGroupHandler.Group.Value;
			if (Handlers[value] != null)
			{
				throw new Exception(type.Name + " has the same index as " + Handlers[value].GetType().Name + ", we can't replace grab handlers!");
			}
			Handlers[value] = grabGroupHandler;
		}

		public static void SerializeGrab(ref SerializedGrab grab, INetSerializer serializer, GrabGroup group)
		{
			try
			{
				Handlers[(uint)group].HandleGrab(ref grab, serializer);
			}
			catch (Exception ex)
			{
				FusionLogger.Error("Failed handling serialized grab with reason: " + ex.Message + "\nTrace:" + ex.StackTrace);
			}
		}
	}
}
namespace LabFusion.Extensions
{
	public static class AlignPlugExtensions
	{
		public static void ForceEject(this AlignPlug plug)
		{
			try
			{
				if (Object.op_Implicit((Object)(object)plug._lastSocket) && !plug._lastSocket.IsClearOnInsert)
				{
					plug.EjectPlug();
					while (plug._isExitTransition)
					{
						plug.Update();
					}
				}
			}
			catch (Exception)
			{
			}
		}
	}
	public static class ByteExtensions
	{
		public static sbyte ToSByte(this float single)
		{
			return (sbyte)(single * 127f);
		}

		public static float ToSingle(this sbyte signedByte)
		{
			return (float)signedByte / 127f;
		}

		public static byte ToByte(this sbyte signedByte)
		{
			return (byte)(signedByte + 128);
		}

		public static sbyte ToSByte(this byte unsignedByte)
		{
			return (sbyte)(unsignedByte - 128);
		}
	}
	public static class GripExtensions
	{
		public static void TryAutoHolster(this Grip grip, RigRefs collection)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (!((HandReciever)grip).HasHost)
			{
				return;
			}
			IGrippable host = ((HandReciever)grip).Host;
			WeaponSlot val = WeaponSlot.Cache.Get(host.GetHostGameObject());
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			for (int i = 0; i < collection.RigSlots.Length; i++)
			{
				InventorySlotReceiver val2 = collection.RigSlots[i];
				if (!((Object)(object)val2._slottedWeapon != (Object)null) && (val2.slotType & val.slotType) != 0)
				{
					((InventoryHandReceiver)val2).OnHandDrop(host);
					break;
				}
			}
		}

		public static void MoveIntoHand(this Grip grip, Hand hand)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((HandReciever)grip).Host.GetTransform();
			SimpleTransform val = grip.SolveHandTarget(hand);
			SimpleTransform val2 = ((SimpleTransform)(ref val)).InverseTransform(SimpleTransform.Create(((Component)transform).transform));
			SimpleTransform val3 = SimpleTransform.Create(((Component)hand).transform);
			SimpleTransform val4 = ((SimpleTransform)(ref val3)).Transform(val2);
			transform.position = val4.position;
			transform.rotation = val4.rotation;
			if (((HandReciever)grip).HasRigidbody)
			{
				Rigidbody rb = ((HandReciever)grip).Host.Rb;
				rb.velocity = hand.rb.velocity;
				rb.angularVelocity = hand.rb.angularVelocity;
			}
		}

		public static void TryAttach(this Grip grip, Hand hand, bool isInstant = false, SimpleTransform? targetInBase = null)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			hand.TryDetach();
			hand.GrabLock = false;
			InventoryHand component = ((Component)hand).gameObject.GetComponent<InventoryHand>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.IgnoreUnlock();
			}
			hand.HoverLock();
			SimpleTransform val = SimpleTransform.Create(((Component)hand).transform);
			((HandReciever)grip).ValidateGripScore(hand, val);
			grip.OnHandHoverBegin(hand, true);
			((HandReciever)grip).ValidateGripScore(hand, val);
			if (targetInBase.HasValue)
			{
				SetTargetInBase(grip, hand, targetInBase.Value.position, targetInBase.Value.rotation);
			}
			hand._mHoveringReceiver = (HandReciever)(object)grip;
			grip.OnGrabConfirm(hand, isInstant);
			if (targetInBase.HasValue)
			{
				SetTargetInBase(grip, hand, targetInBase.Value.position, targetInBase.Value.rotation);
			}
		}

		private static void SetTargetInBase(Grip grip, Hand hand, Vector3 position, Quaternion rotation)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			grip.SetTargetInBase(hand, position, rotation);
			HandToGripState handState = grip.GetHandState(hand);
			handState.amplifyRotationInBase = rotation;
			handState.targetRotationInBase = rotation;
		}

		public static void TryDetach(this Grip grip, Hand hand)
		{
			if ((Object)(object)hand.m_CurrentAttachedGO == (Object)(object)((Component)grip).gameObject)
			{
				grip.ForceDetach(hand);
			}
		}
	}
	public static class HandExtensions
	{
		public static void TryAutoHolsterGrip(this Hand hand, RigRefs collection)
		{
			if (!((Object)(object)hand.m_CurrentAttachedGO == (Object)null))
			{
				Grip val = Grip.Cache.Get(hand.m_CurrentAttachedGO);
				if ((Object)(object)val != (Object)null)
				{
					val.TryAutoHolster(collection);
				}
			}
		}

		public static void TryDetach(this Hand hand)
		{
			GameObject currentAttachedGO = hand.m_CurrentAttachedGO;
			if (!((Object)(object)currentAttachedGO == (Object)null))
			{
				Grip component = currentAttachedGO.GetComponent<Grip>();
				if ((Object)(object)component != (Object)null)
				{
					component.TryDetach(hand);
				}
			}
		}
	}
	public static class IEnumerableExtensions
	{
		private static readonly Random _random = new Random();

		public static T GetRandom<T>(this IEnumerable<T> enumerable)
		{
			int index = Random.Range(0, enumerable.Count());
			return enumerable.ElementAt(index);
		}

		public static bool ContainsInstance<T>(this List<T> list, T obj) where T : class
		{
			return list.Any((T o) => o == obj);
		}

		public static bool RemoveInstance<T>(this List<T> list, T obj) where T : class
		{
			if (!list.ContainsInstance(obj))
			{
				return false;
			}
			for (int i = 0; i < list.Count; i++)
			{
				if (list.ElementAt(i) == obj)
				{
					list.RemoveAt(i);
					return true;
				}
			}
			return false;
		}

		public static void ForEach<T>(this IEnumerable<T> enumerable, Action<T> action)
		{
			for (int i = 0; i < enumerable.Count(); i++)
			{
				action(enumerable.ElementAt(i));
			}
		}

		public static bool Has<T>(this IEnumerable<T> list, T obj) where T : Object
		{
			return list.Any((T o) => (Object)(object)o == (Object)(object)obj);
		}

		public static bool Has<T>(this List<T> list, T obj) where T : Object
		{
			for (int i = 0; i < list.Count; i++)
			{
				if ((Object)(object)list[i] == (Object)(object)obj)
				{
					return true;
				}
			}
			return false;
		}

		public static void Shuffle<T>(this IList<T> list)
		{
			int num = list.Count;
			while (num > 1)
			{
				num--;
				int num2 = _random.Next(num + 1);
				int index = num;
				int index2 = num2;
				T value = list[num2];
				T value2 = list[num];
				list[index] = value;
				list[index2] = value2;
			}
		}
	}
	public static class Int32Extensions
	{
		public static bool IsNaN(this int value)
		{
			if (value < int.MaxValue)
			{
				return value <= int.MinValue;
			}
			return true;
		}
	}
	public static class InteractableHostExtensions
	{
		public static void TryDetach(this InteractableHost host)
		{
			List<Hand> list = null;
			for (int i = 0; i < host._hands.Count; i++)
			{
				if (list == null)
				{
					list = new List<Hand>();
				}
				list.Add(host._hands[i]);
			}
			if (list != null)
			{
				for (int j = 0; j < list.Count; j++)
				{
					list[j].TryDetach();
				}
			}
		}

		public static void TryDetach(this IGrippable host)
		{
			InteractableHost val = ((Il2CppObjectBase)host).TryCast<InteractableHost>();
			if ((Object)(object)val != (Object)null)
			{
				val.TryDetach();
			}
		}
	}
	public static class QuaternionExtensions
	{
		public static readonly Quaternion identity = Quaternion.identity;
	}
	public static class ReflectionExtensions
	{
		public static string GetNameWithParameters(this MethodInfo method)
		{
			StringBuilder stringBuilder = new StringBuilder(method.Name);
			ParameterInfo[] parameters = method.GetParameters();
			bool flag = true;
			ParameterInfo[] array = parameters;
			foreach (ParameterInfo parameterInfo in array)
			{
				stringBuilder.Append(flag ? ": " : ", ");
				stringBuilder.Append(parameterInfo.ParameterType.FullName);
				flag = false;
			}
			return stringBuilder.ToString();
		}
	}
	public static class StringExtensions
	{
		public const char UniqueSeparator = '¬';

		public static string Contract(this IList<string> list)
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < list.Count; i++)
			{
				string value = list[i];
				stringBuilder.Append(value);
				if (i + 1 < list.Count)
				{
					stringBuilder.Append('¬');
				}
			}
			return stringBuilder.ToString();
		}

		public static string[] Expand(this string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return Array.Empty<string>();
			}
			return value.Split('¬');
		}

		public static string RemoveRichText(this string str)
		{
			if (string.IsNullOrWhiteSpace(str))
			{
				return str;
			}
			Regex regex = new Regex("<[^>]*>");
			string text = str;
			if (regex.IsMatch(text))
			{
				text = regex.Replace(text, string.Empty);
			}
			return text;
		}

		public static string RemoveRichTextExceptColor(this string str)
		{
			if (string.IsNullOrWhiteSpace(str))
			{
				return str;
			}
			Regex regex = new Regex("<(?!\\W*(?i)color(?-i)\\W*)[^>]*>");
			string text = str;
			if (regex.IsMatch(text))
			{
				text = regex.Replace(text, string.Empty);
			}
			return text;
		}

		public static string LimitLength(this string str, int maxLength)
		{
			if (string.IsNullOrEmpty(str))
			{
				return str;
			}
			int length = str.RemoveRichText().Length;
			if (length <= maxLength)
			{
				return str;
			}
			int num = str.Length - length;
			return str.Substring(0, maxLength + num);
		}

		public static int GetDeterministicHashCode(this string str)
		{
			int num = 352654597;
			int num2 = num;
			for (int i = 0; i < str.Length; i += 2)
			{
				num = ((num << 5) + num) ^ str[i];
				if (i == str.Length - 1)
				{
					break;
				}
				num2 = ((num2 << 5) + num2) ^ str[i + 1];
			}
			return num + num2 * 1566083941;
		}
	}
	public static class TransformExtensions
	{
		internal static string GetBasePath(this Transform transform)
		{
			string name = ((Object)transform).name;
			Transform parent = transform.parent;
			if (!((Object)(object)parent == (Object)null))
			{
				return $"{parent.GetBasePath()}{172}{transform.GetSiblingNameIndex()}{172}{name}";
			}
			return $"{172}{name}";
		}

		internal static List<Transform> FindSiblingsWithName(this Transform parent, string name)
		{
			List<Transform> list = new List<Transform>(parent.childCount);
			for (int i = 0; i < parent.childCount; i++)
			{
				Transform child = parent.GetChild(i);
				if (((Object)child).name == name)
				{
					list.Add(child);
				}
			}
			return list;
		}

		internal static int GetSiblingNameIndex(this Transform transform)
		{
			return transform.parent.FindSiblingsWithName(((Object)transform).name).FindIndex((Transform t) => (Object)(object)t == (Object)(object)transform);
		}

		internal static Transform GetTransformByIndex(this Transform parent, int index, string name)
		{
			List<Transform> list = parent.FindSiblingsWithName(name);
			if (list.Count <= 0)
			{
				return null;
			}
			if (list.Count <= index || index < 0)
			{
				return list[list.Count - 1];
			}
			return list[index];
		}
	}
	public class UnityComparer : IEqualityComparer<Object>
	{
		public bool Equals(Object lft, Object rht)
		{
			return lft == rht;
		}

		public int GetHashCode(Object obj)
		{
			return ((Object)obj).GetHashCode();
		}
	}
	public static class UnityObjectExtensions
	{
		public static bool EqualsIL2CPP<T>(this T lft, T rht)
		{
			object obj = lft;
			Object val = (Object)((obj is Object) ? obj : null);
			if (val != null)
			{
				object obj2 = rht;
				Object val2 = (Object)((obj2 is Object) ? obj2 : null);
				if (val2 != null)
				{
					return val.GetInstanceID() == val2.GetInstanceID();
				}
			}
			return lft.GetHashCode() == rht.GetHashCode();
		}
	}
	public static class Vector3Extensions
	{
		public static readonly Vector3 zero = Vector3.zero;

		public static readonly Vector3 one = Vector3.one;

		public static readonly Vector3 left = Vector3.left;

		public static readonly Vector3 right = Vector3.right;

		public static readonly Vector3 forward = Vector3.forward;

		public static readonly Vector3 back = Vector3.back;

		public static readonly Vector3 up = Vector3.up;

		public static readonly Vector3 down = Vector3.down;

		public static Quaternion GetQuaternionDisplacement(this Vector3 displacement)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			float num = GetMagnitude(displacement) * 57.29578f;
			Vector3 val = Normalize(displacement);
			return Quaternion.AngleAxis(num, val);
		}

		public static Vector3 Normalize(Vector3 vector3)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return vector3 / GetMagnitude(vector3);
		}

		public static float GetMagnitude(Vector3 vector3)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			float x = vector3.x;
			float y = vector3.y;
			float z = vector3.z;
			return (float)System.Math.Sqrt(x * x + y * y + z * z);
		}

		public static float GetSqrMagnitude(Vector3 vector3)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			float x = vector3.x;
			float y = vector3.y;
			float z = vector3.z;
			return x * x + y * y + z * z;
		}
	}
	public static class XElementExtensions
	{
		public static bool TryGetAttribute(this XElement element, string tag, out string value, string fallback = "")
		{
			XAttribute xAttribute = element.Attribute(tag);
			value = fallback;
			if (xAttribute != null)
			{
				value = xAttribute.Value;
			}
			return xAttribute != null;
		}
	}
	public static class RigManagerExtensions
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass5_0
		{
			public bool loaded;

			public GameObject avatar;

			internal void <CoWaitAndSwapAvatarRoutine>b__0(GameObject go)
			{
				loaded = true;
				avatar = go;
			}
		}

		[CompilerGenerated]
		private sealed class <CoWaitAndSwapAvatarRoutine>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AvatarCrate crate;

			private <>c__DisplayClass5_0 <>8__1;

			public RigRefs references;

			public Action<bool> callback;

			public Action<string, GameObject> preSwapAvatar;

			private RigManager <rm>5__2;

			private Avatar <avatarComponent>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <CoWaitAndSwapAvatarRoutine>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<rm>5__2 = null;
				<avatarComponent>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01df: Expected O, but got Unknown
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				GameObject val;
				Action onAvatarSwapped;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass5_0();
					<>8__1.loaded = false;
					<>8__1.avatar = null;
					((CrateT<GameObject>)(object)crate).LoadAsset(Action<GameObject>.op_Implicit((Action<GameObject>)delegate(GameObject go)
					{
						<>8__1.loaded = true;
						<>8__1.avatar = go;
					}));
					goto IL_007f;
				case 1:
					<>1__state = -1;
					goto IL_007f;
				case 2:
					{
						<>1__state = -1;
						goto IL_0190;
					}
					IL_007f:
					if (!<>8__1.loaded)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					if (!references.IsValid)
					{
						return false;
					}
					if ((Object)(object)<>8__1.avatar == (Object)null)
					{
						callback?.Invoke(obj: false);
						break;
					}
					<rm>5__2 = references.RigManager;
					val = Object.Instantiate<GameObject>(<>8__1.avatar);
					val.SetActive(false);
					((Object)val).name = ((Object)<>8__1.avatar).name;
					preSwapAvatar?.Invoke(((Scannable)crate).Barcode.ID, val);
					val.transform.parent = ((Component)references.RigManager).transform;
					val.transform.SetLocalPositionAndRotation(Vector3Extensions.zero, QuaternionExtensions.identity);
					<avatarComponent>5__3 = val.GetComponentInParent<Avatar>(true);
					<rm>5__2.SwapAvatar(<avatarComponent>5__3);
					goto IL_0190;
					IL_0190:
					if (references.IsValid && (Object)(object)<rm>5__2.avatar != (Object)(object)<avatarComponent>5__3)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					if (!references.IsValid)
					{
						return false;
					}
					<rm>5__2._avatarCrate = new AvatarCrateReference(((Scannable)crate).Barcode);
					onAvatarSwapped = <rm>5__2.onAvatarSwapped;
					if (onAvatarSwapped != null)
					{
						onAvatarSwapped.Invoke();
					}
					<rm>5__2.onAvatarSwapped2?.Invoke(((Scannable)crate).Barcode);
					callback?.Invoke(obj: true);
					<rm>5__2 = null;
					<avatarComponent>5__3 = null;
					break;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static void TeleportToPosition(this RigManager rigManager, Vector3 position, bool resetVelocity = true)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			PhysicsRig physicsRig = rigManager.physicsRig;
			physicsRig.marrowEntity.ResetPose(resetVelocity);
			((Rig)physicsRig).centerOfPressure.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
			TeleportRig((Rig)(object)physicsRig, position, resetVelocity);
			physicsRig.ResetHands((Handedness)3);
			foreach (Rig item in (Il2CppArrayBase<Rig>)(object)rigManager.remapRigs)
			{
				TeleportRig(item, position, resetVelocity);
			}
		}

		public static void TeleportToPosition(this RigManager rigManager, Vector3 position, Vector3 forward, bool resetVelocity = true)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			RemapRig remapHeptaRig = rigManager.remapHeptaRig;
			PhysicsRig physicsRig = rigManager.physicsRig;
			physicsRig.marrowEntity.ResetPose(resetVelocity);
			((Rig)physicsRig).centerOfPressure.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
			TeleportRig((Rig)(object)physicsRig, position, forward, resetVelocity);
			physicsRig.ResetHands((Handedness)3);
			remapHeptaRig.SetTwist(Vector3.SignedAngle(((Rig)remapHeptaRig).centerOfPressure.forward, forward, Vector3.up));
			foreach (Rig item in (Il2CppArrayBase<Rig>)(object)rigManager.remapRigs)
			{
				TeleportRig(item, position, forward, resetVelocity);
			}
		}

		private static void TeleportRig(Rig rig, Vector3 position, bool resetVelocity)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			SimpleTransform val = SimpleTransform.Create(position - rig.centerOfPressure.position, Quaternion.identity);
			rig.Teleport(val, resetVelocity);
		}

		private static void TeleportRig(Rig rig, Vector3 position, Vector3 forward, bool resetVelocity)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			SimpleTransform val = SimpleTransform.Create(position - rig.centerOfPressure.position, Quaternion.FromToRotation(rig.centerOfPressure.forward, forward));
			rig.Teleport(val, resetVelocity);
		}

		public static void SwapAvatarCrate(this RigRefs references, string barcode, Action<bool> callback = null, Action<string, GameObject> preSwapAvatar = null)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			AvatarCrate crate = ((CrateReferenceT<AvatarCrate>)new AvatarCrateReference(barcode)).Crate;
			if ((Object)(object)crate == (Object)null)
			{
				callback?.Invoke(obj: false);
			}
			else
			{
				MelonCoroutines.Start(CoWaitAndSwapAvatarRoutine(references, crate, callback, preSwapAvatar));
			}
		}

		[IteratorStateMachine(typeof(<CoWaitAndSwapAvatarRoutine>d__5))]
		private static IEnumerator CoWaitAndSwapAvatarRoutine(RigRefs references, AvatarCrate crate, Action<bool> callback = null, Action<string, GameObject> preSwapAvatar = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoWaitAndSwapAvatarRoutine>d__5(0)
			{
				references = references,
				crate = crate,
				callback = callback,
				preSwapAvatar = preSwapAvatar
			};
		}
	}
}
namespace LabFusion.Exceptions
{
	public class MessageExpectedClientException : Exception
	{
		public override string Message => "MessageExpectedClientException: Server has received a Message which expects a Client.";
	}
	public class MessageExpectedServerException : Exception
	{
		public override string Message => "MessageExpectedServerException: Client has received a Message which expects a Server.";
	}
}
namespace LabFusion.Entities
{
	public abstract class EntityComponentArrayExtender<TComponent> : IEntityComponentExtender, IEntityExtender where TComponent : Component
	{
		private NetworkEntity _networkEntity;

		private TComponent[] _registeredComponents;

		private List<TComponent> _dynamicComponents = new List<TComponent>();

		private TComponent[] _components;

		public NetworkEntity NetworkEntity => _networkEntity;

		public TComponent[] Components => _components;

		public bool TryRegister(NetworkEntity entity, GameObject parent)
		{
			TComponent[] array = Il2CppArrayBase<TComponent>.op_Implicit(parent.GetComponentsInChildren<TComponent>(true));
			if (array.Length == 0)
			{
				return false;
			}
			Register(entity, array);
			return true;
		}

		public void Register(NetworkEntity entity, TComponent[] components)
		{
			_networkEntity = entity;
			_registeredComponents = components;
			entity.ConnectExtender(this);
			entity.OnEntityUnregistered += Unregister;
			ApplyComponents();
		}

		public void Unregister()
		{
			if (NetworkEntity != null)
			{
				Unregister(NetworkEntity);
			}
		}

		public void Unregister(NetworkEntity entity)
		{
			if (_networkEntity != null)
			{
				entity.OnEntityUnregistered -= Unregister;
				entity.DisconnectExtender(this);
				OnUnregister(NetworkEntity, Components);
				_networkEntity = null;
				_registeredComponents = null;
				_components = null;
				_dynamicComponents = null;
			}
		}

		public void RegisterDynamics(NetworkEntity entity, GameObject parent)
		{
			Il2CppArrayBase<TComponent> componentsInChildren = parent.GetComponentsInChildren<TComponent>(true);
			if (componentsInChildren.Length > 0)
			{
				_dynamicComponents.AddRange((IEnumerable<TComponent>)componentsInChildren);
				ApplyComponents();
			}
		}

		public void UnregisterDynamics()
		{
			if (_dynamicComponents != null && _dynamicComponents.Count > 0)
			{
				_dynamicComponents.Clear();
				ApplyComponents();
			}
		}

		public ushort? GetIndex(TComponent component)
		{
			for (ushort num = 0; num < Components.Length; num++)
			{
				if ((Object)(object)Components[num] == (Object)(object)component)
				{
					return num;
				}
			}
			return null;
		}

		public TComponent GetComponent(ushort index)
		{
			if (Components != null && Components.Length > index)
			{
				return Components[index];
			}
			return default(TComponent);
		}

		private void ApplyComponents()
		{
			if (Components != null)
			{
				OnUnregister(NetworkEntity, Components);
				_components = null;
			}
			int num = _registeredComponents.Length;
			int count = _dynamicComponents.Count;
			_components = new TComponent[num + count];
			for (int i = 0; i < num; i++)
			{
				_components[i] = _registeredComponents[i];
			}
			for (int j = 0; j < count; j++)
			{
				_components[j + num] = _dynamicComponents[j];
			}
			OnRegister(NetworkEntity, Components);
		}

		protected abstract void OnRegister(NetworkEntity entity, TComponent[] components);

		protected abstract void OnUnregister(NetworkEntity entity, TComponent[] components);
	}
	public abstract class EntityComponentExtender<TComponent> : IEntityComponentExtender, IEntityExtender where TComponent : Component
	{
		private NetworkEntity _networkEntity;

		private TComponent _component;

		public NetworkEntity NetworkEntity => _networkEntity;

		public TComponent Component => _component;

		public bool TryRegister(NetworkEntity entity, GameObject parent)
		{
			TComponent component = GetComponent(parent);
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			Register(entity, component);
			return true;
		}

		public void Register(NetworkEntity entity, TComponent component)
		{
			_networkEntity = entity;
			_component = component;
			entity.ConnectExtender(this);
			entity.OnEntityUnregistered += Unregister;
			OnRegister(NetworkEntity, Component);
		}

		public void Unregister()
		{
			if (NetworkEntity != null)
			{
				Unregister(NetworkEntity);
			}
		}

		public void Unregister(NetworkEntity entity)
		{
			if (_networkEntity != null)
			{
				entity.OnEntityUnregistered -= Unregister;
				entity.DisconnectExtender(this);
				OnUnregister(NetworkEntity, Component);
				_networkEntity = null;
				_component = default(TComponent);
			}
		}

		public void RegisterDynamics(NetworkEntity entity, GameObject parent)
		{
		}

		public void UnregisterDynamics()
		{
		}

		protected abstract void OnRegister(NetworkEntity entity, TComponent component);

		protected abstract void OnUnregister(NetworkEntity entity, TComponent component);

		protected virtual TComponent GetComponent(GameObject go)
		{
			return go.GetComponentInChildren<TComponent>(true);
		}
	}
	public static class EntityComponentManager
	{
		private static int _lastExtenderIndex = 0;

		public static readonly Type[] ExtenderTypes = new Type[1024];

		public static readonly Func<IEntityComponentExtender>[] ExtenderFactories = new Func<IEntityComponentExtender>[1024];

		public static void LoadComponents(Assembly assembly)
		{
			if (assembly == null)
			{
				throw new NullReferenceException("Can't register from a null assembly!");
			}
			AssemblyUtilities.LoadAllValid<IEntityComponentExtender>(assembly, RegisterComponent);
		}

		public static void RegisterComponent<T>() where T : IEntityComponentExtender
		{
			RegisterComponent(typeof(T));
		}

		private static void RegisterComponent(Type type)
		{
			if (ExtenderTypes.Contains(type))
			{
				throw new ArgumentException("Extender type " + type.Name + " was already registered.");
			}
			int num = _lastExtenderIndex++;
			ExtenderTypes[num] = type;
			ExtenderFactories[num] = CreateExtenderFactory(type);
		}

		public static HashSet<IEntityComponentExtender> ApplyComponents(NetworkEntity entity, GameObject parent)
		{
			HashSet<IEntityComponentExtender> hashSet = new HashSet<IEntityComponentExtender>();
			for (int i = 0; i < _lastExtenderIndex; i++)
			{
				IEntityComponentExtender entityComponentExtender = ExtenderFactories[i]();
				if (entityComponentExtender.TryRegister(entity, parent))
				{
					hashSet.Add(entityComponentExtender);
				}
			}
			return hashSet;
		}

		public static HashSet<IEntityComponentExtender> ApplyDynamicComponents(NetworkEntity entity, GameObject parent)
		{
			HashSet<IEntityComponentExtender> hashSet = new HashSet<IEntityComponentExtender>();
			for (int i = 0; i < _lastExtenderIndex; i++)
			{
				Type type = ExtenderTypes[i];
				if (entity.GetExtender(type) is IEntityComponentExtender entityComponentExtender)
				{
					entityComponentExtender.RegisterDynamics(entity, parent);
					continue;
				}
				IEntityComponentExtender entityComponentExtender2 = ExtenderFactories[i]();
				if (entityComponentExtender2.TryRegister(entity, parent))
				{
					hashSet.Add(entityComponentExtender2);
				}
			}
			return hashSet;
		}

		private static Func<IEntityComponentExtender> CreateExtenderFactory(Type type)
		{
			return Expression.Lambda<Func<IEntityComponentExtender>>(Expression.New(type), Array.Empty<ParameterExpression>()).Compile();
		}
	}
	public abstract class EntityComponentParentExtender<TComponent> : EntityComponentExtender<TComponent> where TComponent : Component
	{
		protected override TComponent GetComponent(GameObject go)
		{
			return go.GetComponentInParent<TComponent>(true);
		}
	}
	public interface IEntityComponentExtender : IEntityExtender
	{
		bool TryRegister(NetworkEntity entity, GameObject parent);

		void Unregister();

		void RegisterDynamics(NetworkEntity entity, GameObject parent);

		void UnregisterDynamics();
	}
	public enum EntitySource
	{
		None,
		Scene,
		Player
	}
	public sealed class EntityUpdatableManager
	{
		public RegistrableList<IEntityUpdatable> UpdateManager { get; } = new RegistrableList<IEntityUpdatable>();


		public RegistrableList<IEntityFixedUpdatable> FixedUpdateManager { get; } = new RegistrableList<IEntityFixedUpdatable>();


		public RegistrableList<IEntityLateUpdatable> LateUpdateManager { get; } = new RegistrableList<IEntityLateUpdatable>();


		public void OnEntityUpdate(float deltaTime)
		{
			foreach (IEntityUpdatable entry in UpdateManager.Entries)
			{
				try
				{
					entry.OnEntityUpdate(deltaTime);
				}
				catch (Exception e)
				{
					FusionLogger.LogException("running IEntityUpdatable Update", e);
				}
			}
		}

		public void OnEntityFixedUpdate(float deltaTime)
		{
			foreach (IEntityFixedUpdatable entry in FixedUpdateManager.Entries)
			{
				try
				{
					entry.OnEntityFixedUpdate(deltaTime);
				}
				catch (Exception e)
				{
					FusionLogger.LogException("running IEntityFixedUpdatable FixedUpdate", e);
				}
			}
		}

		public void OnEntityLateUpdate(float deltaTime)
		{
			foreach (IEntityLateUpdatable entry in LateUpdateManager.Entries)
			{
				try
				{
					entry.OnEntityLateUpdate(deltaTime);
				}
				catch (Exception e)
				{
					FusionLogger.LogException("running IEntityLateUpdatable LateUpdate", e);
				}
			}
		}
	}
	public interface IEntityExtender
	{
	}
	public interface IMarrowEntityExtender : IEntityExtender
	{
		static readonly FusionComponentCache<MarrowEntity, NetworkEntity> Cache = new FusionComponentCache<MarrowEntity, NetworkEntity>();

		NetworkEntity NetworkEntity { get; }

		MarrowEntity MarrowEntity { get; }

		void OnEntityCull(bool isInactive);

		void TeleportToPose();

		void HookOnReady(Action callback);
	}
	public delegate void EntityIDEvent<TEntity>(ushort id, TEntity entity);
	public class EntityIDList<TEntity>
	{
		private readonly Dictionary<ushort, TEntity> _idsToEntities = new Dictionary<ushort, TEntity>();

		private readonly Dictionary<TEntity, ushort> _entitiesToIDs = new Dictionary<TEntity, ushort>();

		private readonly HashSet<ushort> _reservedIDs = new HashSet<ushort>();

		private ushort _lastID;

		public Dictionary<ushort, TEntity> IDEntityLookup => _idsToEntities;

		public Dictionary<TEntity, ushort> EntityIDLookup => _entitiesToIDs;

		public HashSet<ushort> ReservedIDs => _reservedIDs;

		public ushort LastID => _lastID;

		public event EntityIDEvent<TEntity> OnEntityAdded;

		public event EntityIDEvent<TEntity> OnEntityRemoved;

		public void ReserveID(ushort id)
		{
			if (!_reservedIDs.Contains(id))
			{
				if (_lastID <= id)
				{
					_lastID = id;
					_lastID++;
				}
				_reservedIDs.Add(id);
			}
		}

		public void Unreserve(ushort id)
		{
			_reservedIDs.Remove(id);
		}

		public bool IsReserved(ushort id)
		{
			return _reservedIDs.Contains(id);
		}

		private bool IsUsedID(ushort id)
		{
			if (!IDEntityLookup.ContainsKey(id))
			{
				return IsReserved(id);
			}
			return true;
		}

		public ushort AllocateNewID()
		{
			_lastID++;
			if (IsUsedID(LastID))
			{
				while (IsUsedID(LastID) && LastID < ushort.MaxValue)
				{
					_lastID++;
				}
			}
			return LastID;
		}

		public bool HasEntity(ushort id)
		{
			return _idsToEntities.ContainsKey(id);
		}

		public TEntity GetEntity(ushort id)
		{
			if (_idsToEntities.TryGetValue(id, out var value))
			{
				return value;
			}
			return default(TEntity);
		}

		public void AddEntity(ushort id, TEntity entity)
		{
			_idsToEntities.Add(id, entity);
			_entitiesToIDs.Add(entity, id);
			this.OnEntityAdded?.Invoke(id, entity);
		}

		public void RemoveEntity(ushort id)
		{
			if (_idsToEntities.ContainsKey(id))
			{
				TEntity entity = _idsToEntities[id];
				RemoveEntity(id, entity);
			}
		}

		public void RemoveEntity(TEntity entity)
		{
			if (_entitiesToIDs.ContainsKey(entity))
			{
				ushort id = _entitiesToIDs[entity];
				RemoveEntity(id, entity);
			}
		}

		private void RemoveEntity(ushort id, TEntity entity)
		{
			_idsToEntities.Remove(id);
			_entitiesToIDs.Remove(entity);
			this.OnEntityRemoved?.Invoke(id, entity);
		}

		public void ClearID()
		{
			_lastID = 0;
			while (IsUsedID(LastID) && LastID < ushort.MaxValue)
			{
				_lastID++;
			}
		}

		public void Clear()
		{
			foreach (KeyValuePair<ushort, TEntity> idsToEntity in _idsToEntities)
			{
				this.OnEntityRemoved?.Invoke(idsToEntity.Key, idsToEntity.Value);
			}
			_idsToEntities.Clear();
			_entitiesToIDs.Clear();
			ClearID();
		}
	}
	public class EntityIDManager<TEntity> where TEntity : INetworkRegistrable
	{
		private readonly EntityIDList<TEntity> _registeredEntities = new EntityIDList<TEntity>();

		private readonly EntityIDList<TEntity> _queuedEntities = new EntityIDList<TEntity>();

		public EntityIDList<TEntity> RegisteredEntities => _registeredEntities;

		public EntityIDList<TEntity> QueuedEntities => _queuedEntities;

		public event Action<TEntity> OnEntityRegistered;

		public event Action<TEntity> OnEntityUnregistered;

		public void RegisterEntity(ushort id, TEntity entity)
		{
			RegisteredEntities.AddEntity(id, entity);
			entity.Register(id);
			this.OnEntityRegistered?.InvokeSafe(entity, "executing OnEntityRegistered hook");
		}

		public void UnregisterEntity(ushort id)
		{
			if (RegisteredEntities.HasEntity(id))
			{
				TEntity entity = RegisteredEntities.GetEntity(id);
				RegisteredEntities.RemoveEntity(id);
				entity.Unregister();
				this.OnEntityUnregistered?.InvokeSafe(entity, "executing OnEntityUnregistered hook");
			}
		}

		public void UnregisterEntity(TEntity entity)
		{
			if (entity.IsQueued)
			{
				QueuedEntities.RemoveEntity(entity);
			}
			if (entity.IsRegistered)
			{
				UnregisterEntity(entity.ID);
			}
		}

		public ushort QueueEntity(TEntity entity)
		{
			ushort num = QueuedEntities.AllocateNewID();
			QueuedEntities.AddEntity(num, entity);
			entity.Queue(num);
			return num;
		}

		public (bool, TEntity) UnqueueEntity(ushort queuedId, ushort allocatedId)
		{
			if (!QueuedEntities.HasEntity(queuedId))
			{
				return (false, default(TEntity));
			}
			TEntity entity = QueuedEntities.GetEntity(queuedId);
			QueuedEntities.RemoveEntity(entity);
			if (entity.IsDestroyed)
			{
				FusionLogger.Warn($"Attempted to unqueue an Entity with allocated id {allocatedId}, but it was destroyed!");
				return (false, default(TEntity));
			}
			RegisterEntity(allocatedId, entity);
			return (true, entity);
		}
	}
	public interface IEntityUpdatable
	{
		void OnEntityUpdate(float deltaTime);
	}
	public interface IEntityFixedUpdatable
	{
		void OnEntityFixedUpdate(float deltaTime);
	}
	public interface IEntityLateUpdatable
	{
		void OnEntityLateUpdate(float deltaTime);
	}
	public interface INetworkOwnable
	{
		PlayerID OwnerID { get; }

		bool IsOwner { get; }

		bool IsOwnerLocked { get; }

		void SetOwner(PlayerID ownerId);

		void LockOwner();

		void UnlockOwner();

		void RemoveOwner();
	}
	public interface INetworkRegistrable
	{
		ushort ID { get; }

		ushort QueueID { get; }

		bool IsRegistered { get; }

		bool IsQueued { get; }

		bool IsDestroyed { get; }

		void Register(ushort id);

		void Queue(ushort queuedId);

		void Unregister();
	}
	public delegate void NetworkEntityDelegate(NetworkEntity entity);
	public delegate void NetworkEntityPlayerDelegate(NetworkEntity entity, PlayerID player);
	public sealed class NetworkEntity : INetworkRegistrable, INetworkOwnable
	{
		private ushort _id;

		private ushort _queueID;

		private bool _isRegistered;

		private bool _isQueued;

		private bool _isDestroyed;

		private bool _isOwnerLocked;

		private PlayerID _ownerID;

		public NetworkEntityPlayerDelegate OnEntityOwnershipTransfer;

		private NetworkEntityDelegate _registeredCallback;

		private readonly List<byte> _dataCaughtUpPlayers = new List<byte>();

		private readonly Dictionary<byte, NetworkEntityPlayerDelegate> _dataCatchupCallbacks = new Dictionary<byte, NetworkEntityPlayerDelegate>();

		private readonly HashSet<IEntityExtender> _extenders = new HashSet<IEntityExtender>();

		public ushort ID => _id;

		public ushort QueueID => _queueID;

		public bool IsRegistered => _isRegistered;

		public bool IsQueued => _isQueued;

		public bool IsDestroyed => _isDestroyed;

		public PlayerID OwnerID => _ownerID;

		public bool IsOwner
		{
			get
			{
				if (HasOwner)
				{
					return OwnerID.IsMe;
				}
				return false;
			}
		}

		public bool HasOwner => OwnerID != null;

		public bool IsOwnerLocked => _isOwnerLocked;

		public EntitySource Source { get; set; }

		public event NetworkEntityDelegate OnEntityUnregistered;

		public event NetworkEntityPlayerDelegate OnEntityCreationCatchup;

		public event NetworkEntityPlayerDelegate OnEntityDataCatchup;

		public void ConnectExtender(IEntityExtender extender)
		{
			_extenders.Add(extender);
		}

		public void DisconnectExtender(IEntityExtender extender)
		{
			_extenders.Remove(extender);
		}

		public TExtender GetExtender<TExtender>() where TExtender : IEntityExtender
		{
			foreach (IEntityExtender extender in _extenders)
			{
				if (extender is TExtender)
				{
					return (TExtender)extender;
				}
			}
			return default(TExtender);
		}

		public IEntityExtender GetExtender(Type type)
		{
			foreach (IEntityExtender extender in _extenders)
			{
				if (type.IsAssignableFrom(extender.GetType()))
				{
					return extender;
				}
			}
			return null;
		}

		internal void OnPlayerLeft(PlayerID playerID)
		{
			byte smallID = playerID.SmallID;
			_dataCaughtUpPlayers.Remove(smallID);
			_dataCatchupCallbacks.Remove(smallID);
			if (OwnerID == playerID)
			{
				RemoveOwner();
			}
		}

		internal bool InvokeCreationCatchup(PlayerID playerID)
		{
			bool result = false;
			if (this.OnEntityCreationCatchup != null)
			{
				this.OnEntityCreationCatchup?.InvokeSafe(this, playerID, "executing OnEntityCreationCatchup");
				result = true;
			}
			return result;
		}

		internal bool InvokeDataCatchup(PlayerID playerID)
		{
			bool result = false;
			byte smallID = playerID.SmallID;
			if (this.OnEntityDataCatchup != null)
			{
				this.OnEntityDataCatchup?.InvokeSafe(this, playerID, "executing OnEntityDataCatchup");
				result = true;
			}
			if (_dataCatchupCallbacks.TryGetValue(smallID, out var value))
			{
				_dataCatchupCallbacks.Remove(smallID);
				value?.InvokeSafe(this, playerID, "executing data catchup callback");
				result = true;
			}
			if (!_dataCaughtUpPlayers.Contains(smallID))
			{
				_dataCaughtUpPlayers.Add(smallID);
			}
			return result;
		}

		public void HookOnRegistered(NetworkEntityDelegate registeredCallback)
		{
			if (IsRegistered)
			{
				registeredCallback?.Invoke(this);
			}
			else
			{
				_registeredCallback = (NetworkEntityDelegate)Delegate.Combine(_registeredCallback, registeredCallback);
			}
		}

		public void HookOnDataCatchup(PlayerID playerID, NetworkEntityPlayerDelegate dataCatchupCallback)
		{
			if (HasDataCaughtUp(playerID))
			{
				dataCatchupCallback?.Invoke(this, playerID);
				return;
			}
			byte smallID = playerID.SmallID;
			if (!_dataCatchupCallbacks.ContainsKey(smallID))
			{
				_dataCatchupCallbacks[smallID] = null;
			}
			Dictionary<byte, NetworkEntityPlayerDelegate> dataCatchupCallbacks = _dataCatchupCallbacks;
			byte key = smallID;
			dataCatchupCallbacks[key] = (NetworkEntityPlayerDelegate)Delegate.Combine(dataCatchupCallbacks[key], dataCatchupCallback);
		}

		public bool HasDataCaughtUp(PlayerID playerID)
		{
			return _dataCaughtUpPlayers.Contains(playerID);
		}

		public void ClearDataCaughtUpPlayers()
		{
			_dataCaughtUpPlayers.Clear();
		}

		public void Queue(ushort queuedId)
		{
			_queueID = queuedId;
			_isQueued = true;
			_isRegistered = false;
			_id = 0;
		}

		public void Register(ushort id)
		{
			_isQueued = false;
			_queueID = 0;
			_isRegistered = true;
			_id = id;
			_registeredCallback?.Invoke(this);
			_registeredCallback = null;
		}

		public void Unregister()
		{
			_isQueued = false;
			_queueID = 0;
			_isRegistered = false;
			_id = 0;
			_isDestroyed = true;
			this.OnEntityUnregistered?.Invoke(this);
			this.OnEntityUnregistered = null;
			this.OnEntityCreationCatchup = null;
			this.OnEntityDataCatchup = null;
			RemoveOwner();
		}

		public void SetOwner(PlayerID ownerID)
		{
			if (!IsOwnerLocked && OwnerID != ownerID)
			{
				_ownerID = ownerID;
				OnEntityOwnershipTransfer?.Invoke(this, ownerID);
			}
		}

		public void RemoveOwner()
		{
			if (!IsOwnerLocked && OwnerID != null)
			{
				_ownerID = null;
				OnEntityOwnershipTransfer?.Invoke(this, null);
			}
		}

		public void LockOwner()
		{
			_isOwnerLocked = true;
		}

		public void UnlockOwner()
		{
			_isOwnerLocked = false;
		}
	}
	public static class NetworkEntityManager
	{
		[CompilerGenerated]
		private sealed class <SendCreationCatchupCoroutine>d__16 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerID playerID;

			private Queue<NetworkEntity> <catchupQueue>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SendCreationCatchupCoroutine>d__16(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<catchupQueue>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<catchupQueue>5__2 = new Queue<NetworkEntity>(IDManager.RegisteredEntities.IDEntityLookup.Values);
					break;
				case 1:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					break;
				}
				while (<catchupQueue>5__2.Count > 0 && !FusionSceneManager.IsLoading() && playerID.IsValid)
				{
					NetworkEntity networkEntity = <catchupQueue>5__2.Dequeue();
					if (networkEntity.IsRegistered && SendCreationCatchup(networkEntity, playerID))
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static readonly EntityIDManager<NetworkEntity> _idManager = new EntityIDManager<NetworkEntity>();

		private static readonly EntityUpdatableManager _updatableManager = new EntityUpdatableManager();

		private static readonly EntityValidationList _ownershipTransferValidators = new EntityValidationList();

		private static readonly Dictionary<ushort, List<NetworkEntityDelegate>> _entityRegisteredCallbacks = new Dictionary<ushort, List<NetworkEntityDelegate>>();

		public static EntityIDManager<NetworkEntity> IDManager => _idManager;

		public static EntityUpdatableManager UpdatableManager => _updatableManager;

		public static EntityValidationList OwnershipTransferValidators => _ownershipTransferValidators;

		public static void OnInitializeManager()
		{
			CatchupManager.OnPlayerServerCatchup += OnPlayerServerCatchup;
			IDManager.OnEntityRegistered += OnEntityRegistered;
			MultiplayerHooking.OnPlayerLeft += OnPlayerLeft;
		}

		public static void OnCleanupIds()
		{
			IDManager.RegisteredEntities.ClearID();
			IDManager.QueuedEntities.ClearID();
			_entityRegisteredCallbacks.Clear();
		}

		public static void OnCleanupEntities()
		{
			foreach (NetworkEntity item in IDManager.RegisteredEntities.EntityIDLookup.Keys.ToList())
			{
				try
				{
					IDManager.UnregisterEntity(item);
				}
				catch (Exception e)
				{
					FusionLogger.LogException("unregistering NetworkEntity", e);
				}
			}
			IDManager.RegisteredEntities.Clear();
			foreach (NetworkEntity item2 in IDManager.QueuedEntities.EntityIDLookup.Keys.ToList())
			{
				try
				{
					item2.Unregister();
				}
				catch (Exception e2)
				{
					FusionLogger.LogException("unregistering queued NetworkEntity", e2);
				}
			}
			IDManager.QueuedEntities.Clear();
			_entityRegisteredCallbacks.Clear();
		}

		private static void OnEntityRegistered(NetworkEntity entity)
		{
			ushort iD = entity.ID;
			if (!_entityRegisteredCallbacks.TryGetValue(iD, out var value))
			{
				return;
			}
			foreach (NetworkEntityDelegate item in value)
			{
				try
				{
					item(entity);
				}
				catch (Exception e)
				{
					FusionLogger.LogException("executing NetworkEntityManager.EntityRegisteredCallback", e);
				}
			}
			_entityRegisteredCallbacks.Remove(iD);
		}

		private static void OnPlayerLeft(PlayerID playerID)
		{
			foreach (NetworkEntity value in IDManager.RegisteredEntities.IDEntityLookup.Values)
			{
				value.OnPlayerLeft(playerID);
			}
		}

		private static void OnPlayerServerCatchup(PlayerID playerID)
		{
			MelonCoroutines.Start(SendCreationCatchupCoroutine(playerID));
		}

		[IteratorStateMachine(typeof(<SendCreationCatchupCoroutine>d__16))]
		private static IEnumerator SendCreationCatchupCoroutine(PlayerID playerID)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SendCreationCatchupCoroutine>d__16(0)
			{
				playerID = playerID
			};
		}

		private static bool SendCreationCatchup(NetworkEntity entity, PlayerID playerId)
		{
			try
			{
				return entity.InvokeCreationCatchup(playerId);
			}
			catch (Exception e)
			{
				FusionLogger.LogException("sending creation catchup for NetworkEntity", e);
			}
			return false;
		}

		public static void OnUpdate(float deltaTime)
		{
			UpdatableManager.OnEntityUpdate(deltaTime);
		}

		public static void OnFixedUpdate(float deltaTime)
		{
			UpdatableManager.OnEntityFixedUpdate(deltaTime);
		}

		public static void OnLateUpdate(float deltaTime)
		{
			UpdatableManager.OnEntityLateUpdate(deltaTime);
		}

		public static void RequestUnqueue(ushort queuedID)
		{
			if (NetworkInfo.HasServer)
			{
				MessageRelay.RelayNative(EntityUnqueueRequestData.Create(PlayerIDManager.LocalSmallID, queuedID), NativeMessageTag.EntityUnqueueRequest, CommonMessageRoutes.ReliableToServer);
			}
		}

		public static void TransferOwnership(NetworkEntity entity, PlayerID ownerID)
		{
			if (OwnershipTransferValidators.Validate(entity, ownerID))
			{
				if (entity.IsOwnerLocked)
				{
					FusionLogger.Warn($"Attempted to transfer ownership for NetworkEntity at ID {entity.ID}, but ownership was locked!");
				}
				else if (!entity.IsRegistered)
				{
					FusionLogger.Warn($"Attempted to transfer ownership for NetworkEntity at ID {entity.ID}, but it wasn't registered!");
				}
				else
				{
					MessageRelay.RelayNative(new EntityPlayerData
					{
						PlayerID = ownerID.SmallID,
						Entity = new NetworkEntityReference(entity)
					}, NativeMessageTag.EntityOwnershipRequest, CommonMessageRoutes.ReliableToServer);
				}
			}
		}

		public static void TakeOwnership(NetworkEntity entity)
		{
			if (!LocalControls.DisableInteraction)
			{
				TransferOwnership(entity, PlayerIDManager.LocalID);
			}
		}

		public static void HookEntityRegistered(ushort id, NetworkEntityDelegate callback)
		{
			NetworkEntity entity = IDManager.RegisteredEntities.GetEntity(id);
			if (entity != null)
			{
				callback(entity);
				return;
			}
			if (!_entityRegisteredCallbacks.ContainsKey(id))
			{
				_entityRegisteredCallbacks[id] = new List<NetworkEntityDelegate>();
			}
			_entityRegisteredCallbacks[id].Add(callback);
		}
	}
	public struct NetworkEntityReference : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 2;

		public ushort ID;

		public readonly int? GetSize()
		{
			return 2;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref ID);
		}

		public readonly void HookEntityRegistered(NetworkEntityDelegate callback)
		{
			NetworkEntityManager.HookEntityRegistered(ID, callback);
		}

		public readonly bool TryGetEntity(out NetworkEntity entity)
		{
			entity = GetEntity();
			return entity != null;
		}

		public readonly NetworkEntity GetEntity()
		{
			return NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(ID);
		}

		public NetworkEntityReference()
			: this(0)
		{
		}

		public NetworkEntityReference(NetworkEntity entity)
			: this(entity.ID)
		{
		}

		public NetworkEntityReference(ushort id)
		{
			ID = id;
		}
	}
	public interface IPlayerUpdatable
	{
		void OnPlayerUpdate(float deltaTime);
	}
	public interface IPlayerFixedUpdatable
	{
		void OnPlayerFixedUpdate(float deltaTime);
	}
	public interface IPlayerLateUpdatable
	{
		void OnPlayerLateUpdate(float deltaTime);
	}
	public class NetworkPlayer : IEntityExtender, IMarrowEntityExtender, IEntityUpdatable, IEntityFixedUpdatable, IEntityLateUpdatable
	{
		[CompilerGenerated]
		private sealed class <WaitAndCreateRig>d__97 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NetworkPlayer <>4__this;

			private int <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WaitAndCreateRig>d__97(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				NetworkPlayer CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					goto IL_0062;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					goto IL_0062;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_0062:
					if (<i>5__2 < 120)
					{
						if (FusionSceneManager.IsLoading())
						{
							return false;
						}
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					break;
				}
				if (IsPlayerLoading())
				{
					if (FusionSceneManager.IsLoading())
					{
						return false;
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				if (CS$<>8__locals0.PlayerID == null || !CS$<>8__locals0.PlayerID.IsValid)
				{
					return false;
				}
				CS$<>8__locals0._puppet.CreatePuppet(CS$<>8__locals0.OnPuppetCreated);
				return false;
				bool IsPlayerLoading()
				{
					if (FusionSceneManager.IsDelayedLoading())
					{
						return true;
					}
					if (CS$<>8__locals0.PlayerID.Metadata.IsValid && CS$<>8__locals0.PlayerID.Metadata.Loading.GetValue())
					{
						return true;
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static readonly FusionComponentCache<RigManager, NetworkPlayer> RigCache = new FusionComponentCache<RigManager, NetworkPlayer>();

		public static readonly HashSet<NetworkPlayer> Players = new HashSet<NetworkPlayer>();

		private NetworkEntity _networkEntity;

		private PlayerID _playerID;

		private string _username = "No Name";

		private MarrowEntity _marrowEntity;

		private RigRefs _rigRefs;

		private RigSkeleton _rigSkeleton;

		private ManagedTransform[] _smoothTrackedTransforms;

		private RigPose _pose;

		private bool _receivedPose;

		private RigPuppet _puppet;

		private RigNameTag _nametag;

		private RigIcon _icon;

		private RigHeadUI _headUI;

		private RigArt _art;

		private RigPhysics _physics;

		private RigGrabber _grabber;

		private RigAvatarSetter _avatarSetter;

		private RigHealthBar _healthBar;

		private RigLivesBar _livesBar;

		private RigVoiceSource _voiceSource;

		private bool _isPhysicsRigDirty;

		private Queue<PhysicsRigStateData> _physicsRigStates = new Queue<PhysicsRigStateData>();

		private bool _isSettingsDirty;

		private bool _isServerDirty;

		public SerializedPlayerSettings playerSettings;

		private PDController _pelvisPDController;

		private bool _isCulled;

		private bool _forceHide;

		private readonly JawFlapper _jawFlapper = new JawFlapper();

		private Action _onAvatarSwappedAction;

		private HashSet<IEntityComponentExtender> _registeredComponentExtenders;

		private HashSet<IEntityComponentExtender> _dynamicComponentExtenders;

		private Action _onReadyCallback;

		public NetworkEntity NetworkEntity => _networkEntity;

		public MarrowEntity MarrowEntity => _marrowEntity;

		public PlayerID PlayerID => _playerID;

		public string Username => _username;

		public RigRefs RigRefs => _rigRefs;

		public RigSkeleton RigSkeleton => _rigSkeleton;

		public ManagedTransform[] SmoothTrackedTransforms => _smoothTrackedTransforms;

		public RigPose RigPose => _pose;

		public bool ReceivedPose => _receivedPose;

		public RigPuppet Puppet => _puppet;

		public RigIcon Icon => _icon;

		public RigHeadUI HeadUI => _headUI;

		public RigGrabber Grabber => _grabber;

		public RigAvatarSetter AvatarSetter => _avatarSetter;

		public RigHealthBar HealthBar => _healthBar;

		public RigLivesBar LivesBar => _livesBar;

		public RigVoiceSource VoiceSource => _voiceSource;

		public bool HasRig
		{
			get
			{
				if (RigRefs != null)
				{
					return RigRefs.IsValid;
				}
				return false;
			}
		}

		public bool IsCulled
		{
			get
			{
				return _isCulled;
			}
			private set
			{
				_isCulled = value;
				OnApplyVisiblity();
			}
		}

		public bool ForceHide
		{
			get
			{
				return _forceHide;
			}
			set
			{
				_forceHide = value;
				OnApplyVisiblity();
			}
		}

		public bool IsHidden
		{
			get
			{
				if (ForceHide)
				{
					return true;
				}
				return IsCulled;
			}
		}

		public float DistanceSqr { get; private set; }

		public PlayerUpdatableManager UpdatableManager { get; } = new PlayerUpdatableManager();


		public JawFlapper JawFlapper => _jawFlapper;

		public static event Action<NetworkPlayer> OnNetworkPlayerRegistered;

		public static event Action<NetworkPlayer, RigManager> OnNetworkRigCreated;

		public event Action<bool> OnHiddenChanged;

		public static NetworkPlayer CreatePlayer(NetworkEntity networkEntity, PlayerID playerID)
		{
			NetworkPlayer networkPlayer = new NetworkPlayer(networkEntity, playerID);
			networkPlayer.Initialize();
			return networkPlayer;
		}

		private NetworkPlayer(NetworkEntity networkEntity, PlayerID playerID)
		{
			_networkEntity = networkEntity;
			_playerID = playerID;
			_pelvisPDController = new PDController();
			_puppet = new RigPuppet();
			_nametag = new RigNameTag
			{
				CrownVisible = playerID.IsHost
			};
			_headUI = new RigHeadUI();
			_icon = new RigIcon
			{
				Visible = false
			};
			_healthBar = new RigHealthBar
			{
				Visible = false
			};
			_livesBar = new RigLivesBar
			{
				Visible = false
			};
			_avatarSetter = new RigAvatarSetter(networkEntity);
			_avatarSetter.OnAvatarChanged += UpdateAvatarSettings;
			HeadUI.RegisterElement(_nametag);
			HeadUI.RegisterElement(_avatarSetter.ProgressBar);
			HeadUI.RegisterElement(_icon);
			HeadUI.RegisterElement(_healthBar);
			HeadUI.RegisterElement(_livesBar);
		}

		private void Initialize()
		{
			NetworkEntity.HookOnRegistered(OnPlayerRegistered);
			NetworkEntity.OnEntityUnregistered += OnPlayerUnregistered;
		}

		public void FindRigManager()
		{
			if (NetworkEntity.IsOwner)
			{
				OnFoundRigManager(RigData.Refs.RigManager);
			}
			else
			{
				MelonCoroutines.Start(WaitAndCreateRig());
			}
		}

		[IteratorStateMachine(typeof(<WaitAndCreateRig>d__97))]
		private IEnumerator WaitAndCreateRig()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitAndCreateRig>d__97(0)
			{
				<>4__this = this
			};
		}

		internal void Internal_OnAvatarChanged(string barcode)
		{
			if (!LocalAvatar.IsMatchingAvatar(barcode, AvatarSetter.AvatarBarcode))
			{
				AvatarSetter.SetAvatarDirty();
			}
		}

		private void OnPuppetCreated(RigManager rigManager)
		{
			_headUI.Spawn();
			MarkDirty();
			((Object)((Component)rigManager).gameObject).name = $"{"[RigManager (Networked)]"} (ID {PlayerID.SmallID})";
			DelayUtilities.InvokeNextFrame(delegate
			{
				OnFoundRigManager(rigManager);
			});
		}

		public void MarkDirty()
		{
			AvatarSetter.SetDirty();
			_isSettingsDirty = true;
			_isServerDirty = true;
			_isPhysicsRigDirty = true;
			_physicsRigStates.Clear();
		}

		private void OnLevelLoad()
		{
			if (!NetworkSceneManager.Purgatory)
			{
				FindRigManager();
			}
		}

		private void OnPurgatoryChanged(bool purgatory)
		{
			if (!NetworkEntity.IsOwner && !FusionSceneManager.IsLoading())
			{
				if (purgatory)
				{
					DestroyPuppet();
				}
				else
				{
					FindRigManager();
				}
			}
		}

		private void HookPlayer()
		{
			NetworkEntity.SetOwner(PlayerID);
			NetworkEntity.LockOwner();
			PlayerID.Metadata.Metadata.OnMetadataChanged += OnMetadataChanged;
			PlayerID.OnDestroyedEvent += OnPlayerDestroyed;
			LobbyInfoManager.OnLobbyInfoChanged += OnServerSettingsChanged;
			FusionOverrides.OnOverridesChanged += OnServerSettingsChanged;
			FindRigManager();
			MultiplayerHooking.OnMainSceneInitialized += OnLevelLoad;
			NetworkSceneManager.OnPurgatoryChanged += OnPurgatoryChanged;
		}

		private void UnhookPlayer()
		{
			NetworkEntity.UnlockOwner();
			PlayerID.Metadata.Metadata.OnMetadataChanged -= OnMetadataChanged;
			PlayerID.OnDestroyedEvent -= OnPlayerDestroyed;
			LobbyInfoManager.OnLobbyInfoChanged -= OnServerSettingsChanged;
			FusionOverrides.OnOverridesChanged -= OnServerSettingsChanged;
			if (HasRig)
			{
				UnhookRig();
			}
			DestroyPuppet();
			MultiplayerHooking.OnMainSceneInitialized -= OnLevelLoad;
			NetworkSceneManager.OnPurgatoryChanged -= OnPurgatoryChanged;
		}

		private void DestroyPuppet()
		{
			if (_puppet.HasPuppet)
			{
				_puppet.DestroyPuppet();
			}
			_nametag.Despawn();
			_headUI.Despawn();
		}

		private void OnMetadataChanged(string key, string value)
		{
			OnMetadataChanged();
		}

		private void OnMetadataChanged()
		{
			if (PlayerID.TryGetDisplayName(out var name))
			{
				_username = name;
			}
			if (!NetworkEntity.IsOwner)
			{
				_nametag.Username = Username;
			}
		}

		private void OnServerSettingsChanged()
		{
			_isServerDirty = true;
			OnMetadataChanged();
		}

		public void EnqueuePhysicsRigState(PhysicsRigStateData data)
		{
			_physicsRigStates.Enqueue(data);
			_isPhysicsRigDirty = true;
		}

		public void SetSettings(SerializedPlayerSettings settings)
		{
			playerSettings = settings;
			_isSettingsDirty = true;
		}

		private void UpdateAvatarSettings()
		{
			if (HasRig)
			{
				_nametag.UpdateText();
				HeadUI.UpdateScale(RigRefs.RigManager);
				VoiceSource?.SetVoiceRange(RigRefs.RigManager.avatar.height);
			}
		}

		private void OnPlayerDestroyed()
		{
			if (!NetworkEntity.IsDestroyed)
			{
				NetworkEntityManager.IDManager.UnregisterEntity(NetworkEntity);
			}
		}

		private void OnPlayerRegistered(NetworkEntity entity)
		{
			Players.Add(this);
			HookPlayer();
			entity.ConnectExtender(this);
			OnReregisterUpdates();
			OnMetadataChanged();
			NetworkPlayer.OnNetworkPlayerRegistered?.InvokeSafe(this, "executing OnNetworkPlayerRegistered hook");
		}

		private void OnPlayerUnregistered(NetworkEntity entity)
		{
			Players.Remove(this);
			UnhookPlayer();
			entity.DisconnectExtender(this);
			_networkEntity = null;
			_playerID = null;
			VoiceSource?.DestroyVoiceSource();
			_voiceSource = null;
			OnUnregisterUpdates();
		}

		public void OnHandUpdate(Hand hand)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			Handedness handedness = hand.handedness;
			if ((int)handedness != 1)
			{
				if ((int)handedness == 2)
				{
					RigPose.RightController?.CopyTo(hand.Controller);
				}
			}
			else
			{
				RigPose.LeftController?.CopyTo(hand.Controller);
			}
		}

		public void OnEntityUpdate(float deltaTime)
		{
			OnPlayerUpdate(deltaTime);
			UpdatableManager.OnPlayerUpdate(deltaTime);
		}

		private void OnPlayerUpdate(float deltaTime)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			if (HasRig)
			{
				RemapRig remapRig = RigSkeleton.RemapRig;
				remapRig._crouchSpeedLimit = ManagedMathf.Clamp01(remapRig._crouchSpeedLimit);
				if (NetworkEntity.IsOwner)
				{
					OnOwnedUpdate();
					JawFlapper.UpdateJaw(VoiceInfo.VoiceAmplitude, deltaTime);
					return;
				}
				OnHandUpdate(RigRefs.LeftHand);
				OnHandUpdate(RigRefs.RightHand);
				VoiceSource?.UpdateVoiceSource(DistanceSqr, deltaTime);
				remapRig._crouchTarget = RigPose.CrouchTarget;
				remapRig._feetOffset = RigPose.FeetOffset;
				Transform trackedPlayspace = RigSkeleton.TrackedPlayspace;
				trackedPlayspace.rotation = Quaternion.Slerp(trackedPlayspace.rotation, RigPose.TrackedPlayspaceExpanded, NetworkTickManager.InterpolationTime);
			}
		}

		public void OnEntityFixedUpdate(float deltaTime)
		{
			OnPlayerFixedUpdate(deltaTime);
			UpdatableManager.OnPlayerFixedUpdate(deltaTime);
		}

		private void OnPlayerFixedUpdate(float deltaTime)
		{
			if (HasRig && !NetworkEntity.IsOwner)
			{
				OnApplyBodyForces(deltaTime);
			}
		}

		public void OnEntityLateUpdate(float deltaTime)
		{
			OnPlayerLateUpdate(deltaTime);
			UpdatableManager.OnPlayerLateUpdate(deltaTime);
		}

		private void OnPlayerLateUpdate(float deltaTime)
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkEntity.IsOwner || !HasRig)
			{
				return;
			}
			_headUI.UpdateTransform(RigRefs.RigManager);
			RigManager rigManager = RigRefs.RigManager;
			AvatarSetter.Resolve(RigRefs);
			if (_isPhysicsRigDirty)
			{
				PhysicsRig physicsRig = rigManager.physicsRig;
				while (_physicsRigStates.Count > 0)
				{
					_physicsRigStates.Dequeue().Apply(physicsRig);
				}
				_isPhysicsRigDirty = false;
			}
			if (_isSettingsDirty)
			{
				if (playerSettings != null)
				{
					Color nametagColor = playerSettings.NametagColor;
					nametagColor.a = 1f;
					_nametag.Color = nametagColor;
				}
				_isSettingsDirty = false;
			}
			if (_isServerDirty)
			{
				UpdateNametagVisibility();
				_isServerDirty = false;
			}
			Vector3 val = RigRefs.Head.position - RigData.Refs.Head.position;
			DistanceSqr = ((Vector3)(ref val)).sqrMagnitude;
		}

		private void OnCullExtras()
		{
			_headUI.Visible = false;
			if (HasRig)
			{
				_art.CullArt(isInactive: true);
				_physics.CullPhysics(isInactive: true);
			}
		}

		private void OnUncullExtras()
		{
			_headUI.Visible = true;
			if (HasRig)
			{
				_art.CullArt(isInactive: false);
				_physics.CullPhysics(isInactive: false);
			}
		}

		private void UpdateNametagVisibility()
		{
			_nametag.Visible = CommonPreferences.NameTags && FusionOverrides.ValidateNametag(PlayerID);
		}

		public void OnEntityCull(bool isInactive)
		{
			if (!NetworkEntity.IsOwner)
			{
				IsCulled = isInactive;
			}
		}

		private void OnApplyVisiblity()
		{
			if (!NetworkEntity.IsOwner)
			{
				bool isHidden = IsHidden;
				if (HasRig)
				{
					ApplyHidden(isHidden);
				}
				this.OnHiddenChanged?.InvokeSafe(isHidden, "executing NetworkPlayer.OnHiddenChanged");
			}
		}

		private void ApplyHidden(bool hidden)
		{
			if (hidden)
			{
				OnCullExtras();
				OnUnregisterUpdates();
			}
			else
			{
				OnUncullExtras();
				OnReregisterUpdates();
				TeleportToPose();
			}
			Grabber.OnEntityCull(hidden);
		}

		private void OnReregisterUpdates()
		{
			OnUnregisterUpdates();
			EntityUpdatableManager updatableManager = NetworkPlayerManager.UpdatableManager;
			updatableManager.UpdateManager.Register(this);
			updatableManager.FixedUpdateManager.Register(this);
			updatableManager.LateUpdateManager.Register(this);
		}

		private void OnUnregisterUpdates()
		{
			EntityUpdatableManager updatableManager = NetworkPlayerManager.UpdatableManager;
			updatableManager.UpdateManager.Unregister(this);
			updatableManager.FixedUpdateManager.Unregister(this);
			updatableManager.LateUpdateManager.Unregister(this);
		}

		public void TeleportToPose()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (ReceivedPose && HasRig)
			{
				Vector3 val = RigPose.PelvisPose.PredictedPosition - ((Component)RigSkeleton.PhysicsPelvis).transform.position;
				Vector3 position = ((Rig)RigRefs.RigManager.physicsRig).centerOfPressure.position + val;
				RigRefs.RigManager.TeleportToPosition(position);
				_pelvisPDController.Reset();
			}
		}

		private void OnOwnedUpdate()
		{
			if (NetworkTickManager.IsTickThisFrame)
			{
				RigPose.ReadSkeleton(RigSkeleton);
				MessageRelay.RelayNative(PlayerPoseUpdateData.Create(RigPose), NativeMessageTag.PlayerPoseUpdate, CommonMessageRoutes.UnreliableToOtherClients);
			}
		}

		private void OnApplyBodyForces(float deltaTime)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			if (!ReceivedPose)
			{
				return;
			}
			BodyPose pelvisPose = RigPose.PelvisPose;
			if (pelvisPose == null)
			{
				_pelvisPDController.Reset();
				return;
			}
			RigManager rigManager = RigRefs.RigManager;
			if (Object.op_Implicit((Object)(object)rigManager.activeSeat))
			{
				_pelvisPDController.Reset();
				return;
			}
			Rigidbody physicsPelvis = RigSkeleton.PhysicsPelvis;
			Vector3 position = physicsPelvis.position;
			Quaternion rotation = physicsPelvis.rotation;
			pelvisPose.PredictPosition(deltaTime);
			Vector3 velocity = position - pelvisPose.PredictedPosition;
			if (((Vector3)(ref velocity)).sqrMagnitude > 2f * (((Vector3)(ref pelvisPose.Velocity)).magnitude + 1f))
			{
				TeleportToPose();
				return;
			}
			PDController pelvisPDController = _pelvisPDController;
			velocity = physicsPelvis.velocity;
			Vector3 targetPos = pelvisPose.PredictedPosition;
			physicsPelvis.AddForce(pelvisPDController.GetForce(in position, in velocity, in targetPos, in pelvisPose.Velocity), (ForceMode)5);
			if (!rigManager.physicsRig.ballLocoEnabled)
			{
				PDController pelvisPDController2 = _pelvisPDController;
				velocity = physicsPelvis.angularVelocity;
				physicsPelvis.AddTorque(pelvisPDController2.GetTorque(in rotation, in velocity, in pelvisPose.Rotation, in pelvisPose.AngularVelocity), (ForceMode)5);
			}
			else
			{
				_pelvisPDController.ResetRotation();
			}
		}

		public void OnReceivePose(RigPose pose)
		{
			if (HasRig)
			{
				_pose = pose;
				if (!ReceivedPose)
				{
					_receivedPose = true;
					TeleportToPose();
					CopyPosePointsToSmoothPoints();
				}
				HealthBar.Health = pose.Health;
				HealthBar.MaxHealth = pose.MaxHealth;
				RigSkeleton.Health.curr_Health = pose.Health;
				RigSkeleton.Health.max_Health = pose.MaxHealth;
			}
		}

		private void CopyPosePointsToSmoothPoints()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (ReceivedPose)
			{
				for (int i = 0; i < 3; i++)
				{
					SerializedLocalTransform serializedLocalTransform = RigPose.TrackedPoints[i];
					SmoothTrackedTransforms[i] = new ManagedTransform(serializedLocalTransform.position, serializedLocalTransform.rotation);
				}
			}
		}

		public void OnOverrideControllerRig()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			if (!ReceivedPose)
			{
				RigRefs.RigManager.remapHeptaRig.inWeight = 0f;
				return;
			}
			RigRefs.RigManager.remapHeptaRig.inWeight = 1f;
			for (int i = 0; i < 3; i++)
			{
				SerializedLocalTransform serializedLocalTransform = RigPose.TrackedPoints[i];
				ManagedTransform managedTransform = SmoothTrackedTransforms[i];
				managedTransform = new ManagedTransform(Vector3.Lerp(managedTransform.Position, serializedLocalTransform.position, NetworkTickManager.InterpolationTime), Quaternion.Slerp(managedTransform.Rotation, serializedLocalTransform.rotation, NetworkTickManager.InterpolationTime));
				SmoothTrackedTransforms[i] = managedTransform;
				RigSkeleton.TrackedPoints[i].SetLocalPositionAndRotation(managedTransform.Position, managedTransform.Rotation);
			}
		}

		private void OnRigDestroyed()
		{
			_pose = null;
			_receivedPose = false;
			NetworkEntity?.ClearDataCaughtUpPlayers();
			UnregisterComponents();
		}

		private void OnFoundRigManager(RigManager rigManager)
		{
			_marrowEntity = rigManager.physicsRig.marrowEntity;
			_rigSkeleton = new RigSkeleton(rigManager);
			_rigRefs = new RigRefs(rigManager);
			_smoothTrackedTransforms = new ManagedTransform[3];
			_rigRefs.HookOnDestroy(OnRigDestroyed);
			_pose = new RigPose();
			_grabber = new RigGrabber(RigRefs);
			_art = new RigArt(rigManager);
			_physics = new RigPhysics(rigManager);
			HookRig();
			RegisterComponents();
			if (!NetworkEntity.IsOwner)
			{
				TeleportToPose();
				OnEntityCull(MarrowEntity.IsCulled);
				_voiceSource = new RigVoiceSource(JawFlapper, ((Component)rigManager.physicsRig.headSfx.mouthSrc).transform);
				_voiceSource.CreateVoiceSource(PlayerID.SmallID);
			}
			NetworkPlayer.OnNetworkRigCreated?.InvokeSafe<Action<NetworkPlayer, RigManager>, NetworkPlayer, RigManager>(this, rigManager, "executing OnNetworkRigCreated hook");
			_onReadyCallback?.InvokeSafe("executing NetworkPlayer.OnReadyCallback");
			_onReadyCallback = null;
			if (!NetworkEntity.IsOwner)
			{
				CatchupManager.RequestEntityDataCatchup(new NetworkEntityReference(NetworkEntity));
			}
		}

		private void HookRig()
		{
			RigCache.Add(RigRefs.RigManager, this);
			IMarrowEntityExtender.Cache.Add(MarrowEntity, NetworkEntity);
			_onAvatarSwappedAction = Action.op_Implicit((Action)OnAvatarSwapped);
			RigManager rigManager = RigRefs.RigManager;
			rigManager.onAvatarSwapped += _onAvatarSwappedAction;
		}

		private void UnhookRig()
		{
			RigCache.Remove(RigRefs.RigManager);
			IMarrowEntityExtender.Cache.Remove(MarrowEntity);
			RigManager rigManager = RigRefs.RigManager;
			rigManager.onAvatarSwapped -= _onAvatarSwappedAction;
			_onAvatarSwappedAction = null;
		}

		private void OnAvatarSwapped()
		{
			RegisterDynamicComponents();
		}

		private void RegisterComponents()
		{
			if (HasRig)
			{
				PhysicsRig physicsRig = RigRefs.RigManager.physicsRig;
				_registeredComponentExtenders = EntityComponentManager.ApplyComponents(NetworkEntity, ((Component)physicsRig).gameObject);
				RegisterDynamicComponents();
			}
		}

		private void RegisterDynamicComponents()
		{
			if (HasRig)
			{
				UnregisterDynamicComponents();
				Avatar avatar = RigRefs.RigManager.avatar;
				_dynamicComponentExtenders = EntityComponentManager.ApplyDynamicComponents(NetworkEntity, ((Component)avatar).gameObject);
			}
		}

		private void UnregisterComponents()
		{
			UnregisterDynamicComponents();
			if (_registeredComponentExtenders == null)
			{
				return;
			}
			foreach (IEntityComponentExtender registeredComponentExtender in _registeredComponentExtenders)
			{
				registeredComponentExtender.Unregister();
			}
			_registeredComponentExtenders.Clear();
		}

		private void UnregisterDynamicComponents()
		{
			if (_registeredComponentExtenders != null)
			{
				foreach (IEntityComponentExtender registeredComponentExtender in _registeredComponentExtenders)
				{
					registeredComponentExtender.UnregisterDynamics();
				}
			}
			if (_dynamicComponentExtenders == null)
			{
				return;
			}
			foreach (IEntityComponentExtender dynamicComponentExtender in _dynamicComponentExtenders)
			{
				dynamicComponentExtender.Unregister();
			}
			_dynamicComponentExtenders.Clear();
		}

		public void HookOnReady(Action callback)
		{
			if (HasRig)
			{
				callback();
			}
			else
			{
				_onReadyCallback = (Action)Delegate.Combine(_onReadyCallback, callback);
			}
		}
	}
	public static class NetworkPlayerManager
	{
		private static readonly EntityUpdatableManager _updatableManager = new EntityUpdatableManager();

		public static EntityUpdatableManager UpdatableManager => _updatableManager;

		public static void OnInitializeManager()
		{
			for (int i = 0; i <= 255; i++)
			{
				NetworkEntityManager.IDManager.RegisteredEntities.ReserveID((ushort)i);
			}
		}

		public static bool HasExternalPlayer(RigManager rigManager)
		{
			if (!TryGetPlayer(rigManager, out var player))
			{
				return false;
			}
			return !player.NetworkEntity.IsOwner;
		}

		public static bool HasExternalPlayer(byte playerID)
		{
			if (!TryGetPlayer(playerID, out var player))
			{
				return false;
			}
			return !player.NetworkEntity.IsOwner;
		}

		public static bool HasPlayer(RigManager rigManager)
		{
			return NetworkPlayer.RigCache.ContainsSource(rigManager);
		}

		public static bool HasPlayer(byte playerID)
		{
			return NetworkEntityManager.IDManager.RegisteredEntities.HasEntity(playerID);
		}

		public static bool TryGetPlayer(byte playerID, out NetworkPlayer player)
		{
			player = null;
			NetworkEntity entity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(playerID);
			if (entity == null)
			{
				return false;
			}
			player = entity.GetExtender<NetworkPlayer>();
			return player != null;
		}

		public static bool TryGetPlayer(RigManager rigManager, out NetworkPlayer player)
		{
			return NetworkPlayer.RigCache.TryGet(rigManager, out player);
		}

		public static bool TryGetPlayer(MarrowEntity marrowEntity, out NetworkPlayer player)
		{
			player = null;
			if (!IMarrowEntityExtender.Cache.TryGet(marrowEntity, out var value))
			{
				return false;
			}
			player = value.GetExtender<NetworkPlayer>();
			return player != null;
		}

		public static NetworkPlayer CreateLocalPlayer()
		{
			return CreateNetworkPlayer(PlayerIDManager.LocalID);
		}

		public static NetworkPlayer CreateNetworkPlayer(PlayerID playerID)
		{
			NetworkEntity networkEntity = new NetworkEntity();
			NetworkPlayer result = NetworkPlayer.CreatePlayer(networkEntity, playerID);
			NetworkEntityManager.IDManager.RegisterEntity(playerID.SmallID, networkEntity);
			return result;
		}

		public static void OnUpdate(float deltaTime)
		{
			UpdatableManager.OnEntityUpdate(deltaTime);
		}

		public static void OnFixedUpdate(float deltaTime)
		{
			UpdatableManager.OnEntityFixedUpdate(deltaTime);
		}

		public static void OnLateUpdate(float deltaTime)
		{
			UpdatableManager.OnEntityLateUpdate(deltaTime);
		}
	}
	public sealed class PlayerUpdatableManager
	{
		public RegistrableList<IPlayerUpdatable> UpdateManager { get; } = new RegistrableList<IPlayerUpdatable>();


		public RegistrableList<IPlayerFixedUpdatable> FixedUpdateManager { get; } = new RegistrableList<IPlayerFixedUpdatable>();


		public RegistrableList<IPlayerLateUpdatable> LateUpdateManager { get; } = new RegistrableList<IPlayerLateUpdatable>();


		public void OnPlayerUpdate(float deltaTime)
		{
			foreach (IPlayerUpdatable entry in UpdateManager.Entries)
			{
				try
				{
					entry.OnPlayerUpdate(deltaTime);
				}
				catch (Exception e)
				{
					FusionLogger.LogException("running IPlayerUpdatable Update", e);
				}
			}
		}

		public void OnPlayerFixedUpdate(float deltaTime)
		{
			foreach (IPlayerFixedUpdatable entry in FixedUpdateManager.Entries)
			{
				try
				{
					entry.OnPlayerFixedUpdate(deltaTime);
				}
				catch (Exception e)
				{
					FusionLogger.LogException("running IPlayerFixedUpdatable FixedUpdate", e);
				}
			}
		}

		public void OnPlayerLateUpdate(float deltaTime)
		{
			foreach (IPlayerLateUpdatable entry in LateUpdateManager.Entries)
			{
				try
				{
					entry.OnPlayerLateUpdate(deltaTime);
				}
				catch (Exception e)
				{
					FusionLogger.LogException("running IPlayerLateUpdatable LateUpdate", e);
				}
			}
		}
	}
	public class RigArt
	{
		private RigManager _rigManager;

		private Renderer[] _physicsRenderers;

		private InventoryAmmoReceiver _ammoReceiver;

		public RigArt(RigManager rigManager)
		{
			_rigManager = rigManager;
			_ammoReceiver = ((Component)rigManager.physicsRig).GetComponentInChildren<InventoryAmmoReceiver>(true);
			List<Renderer> list = new List<Renderer>();
			foreach (Renderer componentsInChild in ((Component)_rigManager.physicsRig).GetComponentsInChildren<Renderer>())
			{
				if (componentsInChild.enabled)
				{
					list.Add(componentsInChild);
				}
			}
			_physicsRenderers = list.ToArray();
		}

		public void CullArt(bool isInactive)
		{
			bool enabled = !isInactive;
			TogglePhysicsRenderers(enabled);
			ToggleAvatar(enabled);
			ToggleAmmoPouch(enabled);
		}

		private void TogglePhysicsRenderers(bool enabled)
		{
			if (_physicsRenderers == null)
			{
				return;
			}
			Renderer[] physicsRenderers = _physicsRenderers;
			foreach (Renderer val in physicsRenderers)
			{
				if (!((Object)(object)val == (Object)null))
				{
					val.enabled = enabled;
				}
			}
		}

		private void ToggleAvatar(bool enabled)
		{
			if (!((Object)(object)_rigManager == (Object)null) && !((Object)(object)_rigManager.avatar == (Object)null))
			{
				((Component)_rigManager.avatar).gameObject.SetActive(enabled);
			}
		}

		private void ToggleAmmoPouch(bool enabled)
		{
			if (!((Object)(object)_ammoReceiver == (Object)null))
			{
				((Component)_ammoReceiver).gameObject.SetActive(enabled);
			}
		}
	}
	public class RigAvatarSetter
	{
		private bool _isAvatarDirty;

		private SerializedAvatarStats _stats;

		private string _avatarBarcode = MarrowBarcodes.EmptyBarcode;

		private RigRefs _references;

		private NetworkEntity _entity;

		private readonly RigProgressBar _progressBar = new RigProgressBar();

		public SerializedAvatarStats AvatarStats => _stats;

		public string AvatarBarcode => _avatarBarcode;

		public RigProgressBar ProgressBar => _progressBar;

		public event Action OnAvatarChanged;

		public RigAvatarSetter(NetworkEntity entity)
		{
			_entity = entity;
			ProgressBar.Visible = false;
		}

		public void SwapAvatar(SerializedAvatarStats stats, string barcode)
		{
			_stats = stats;
			_avatarBarcode = barcode;
			SetAvatarDirty();
			CheckForInstall(barcode);
		}

		private void CheckForInstall(string barcode)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			ProgressBar.Visible = false;
			if (!CrateFilterer.HasCrate<AvatarCrate>(new Barcode(barcode)) && ClientSettings.Downloading.DownloadAvatars.Value)
			{
				long value = DataConversions.ConvertMegabytesToBytes(ClientSettings.Downloading.MaxFileSize.Value);
				byte smallID = _entity.OwnerID.SmallID;
				NetworkModRequester.ModInstallInfo installInfo = default(NetworkModRequester.ModInstallInfo);
				installInfo.Target = smallID;
				installInfo.Barcode = barcode;
				installInfo.BeginDownloadCallback = OnAvatarBeginDownload;
				installInfo.FinishDownloadCallback = OnAvatarDownloaded;
				installInfo.MaxBytes = value;
				installInfo.Reporter = ProgressBar;
				NetworkModRequester.RequestAndInstallMod(installInfo);
			}
		}

		private void OnAvatarBeginDownload(NetworkModRequester.ModCallbackInfo info)
		{
			ProgressBar.Report(0f);
			ProgressBar.Visible = true;
		}

		private void OnAvatarDownloaded(DownloadCallbackInfo info)
		{
			ProgressBar.Visible = false;
			if (info.Result != ModResult.SUCCEEDED)
			{
				FusionLogger.Warn($"Failed downloading avatar for rig {_entity.ID}!");
			}
			else
			{
				SetAvatarDirty();
			}
		}

		public void SetAvatarDirty()
		{
			_isAvatarDirty = true;
		}

		public void SetDirty()
		{
			SetAvatarDirty();
		}

		public void Resolve(RigRefs references)
		{
			_references = references;
			if (_isAvatarDirty)
			{
				references.SwapAvatarCrate(AvatarBarcode, OnSwapAvatar, OnPrepareAvatar);
				_isAvatarDirty = false;
			}
		}

		private void OnSwapAvatar(bool success)
		{
			_ = _references.RigManager;
			if (!success)
			{
				_references.SwapAvatarCrate(((ScannableReference)MarrowGameReferences.CalibrationAvatarReference).Barcode.ID, OnSwapFallback, OnPrepareAvatar);
			}
			else
			{
				this.OnAvatarChanged?.Invoke();
			}
		}

		private void OnSwapFallback(bool success)
		{
			this.OnAvatarChanged?.Invoke();
		}

		private void OnPrepareAvatar(string barcode, GameObject avatar)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (_stats != null)
			{
				Transform transform = avatar.transform;
				if (barcode == ((ScannableReference)MarrowGameReferences.CalibrationAvatarReference).Barcode.ID)
				{
					float height = _stats.height;
					transform.localScale = Vector3Extensions.one * (height / MarrowGameReferences.CalibrationAvatarHeight);
				}
				else
				{
					transform.localScale = _stats.localScale;
				}
			}
		}
	}
	public class RigGrabber
	{
		public class GrabberData
		{
			public Grip Grip;

			public SimpleTransform? TargetInBase;
		}

		[CompilerGenerated]
		private sealed class <WaitAndUncullGrips>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RigGrabber <>4__this;

			private int <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WaitAndUncullGrips>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				RigGrabber rigGrabber = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < 120)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				rigGrabber.UncullGrip((Handedness)1);
				rigGrabber.UncullGrip((Handedness)2);
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private readonly RigRefs _references;

		private bool _isCulled;

		private Dictionary<Handedness, GrabberData> _lastGrabs = new Dictionary<Handedness, GrabberData>();

		public bool IsCulled => _isCulled;

		public RigGrabber(RigRefs references)
		{
			_references = references;
		}

		public void OnEntityCull(bool isInactive)
		{
			_isCulled = isInactive;
			if (isInactive)
			{
				DetachWithoutClear((Handedness)1);
				DetachWithoutClear((Handedness)2);
			}
			else
			{
				MelonCoroutines.Start(WaitAndUncullGrips());
			}
		}

		[IteratorStateMachine(typeof(<WaitAndUncullGrips>d__8))]
		private IEnumerator WaitAndUncullGrips()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitAndUncullGrips>d__8(0)
			{
				<>4__this = this
			};
		}

		public void Attach(Handedness handedness, Grip grip, SimpleTransform? targetInBase = null)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			_lastGrabs[handedness] = new GrabberData
			{
				Grip = grip,
				TargetInBase = targetInBase
			};
			if (IsCulled)
			{
				return;
			}
			Hand hand = _references.GetHand(handedness);
			if (!((Object)(object)hand == (Object)null) && Object.op_Implicit((Object)(object)grip))
			{
				hand.TryDetach();
				if (!grip.IsInteractionDisabled && (!((HandReciever)grip).HasHost || !((HandReciever)grip).Host.IsInteractionDisabled))
				{
					grip.TryAttach(hand, isInstant: false, targetInBase);
				}
			}
		}

		public void Detach(Handedness handedness)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			_lastGrabs.Remove(handedness);
			DetachWithoutClear(handedness);
		}

		private void DetachWithoutClear(Handedness handedness)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Hand hand = _references.GetHand(handedness);
			if (!((Object)(object)hand == (Object)null))
			{
				hand.TryDetach();
			}
		}

		private void UncullGrip(Handedness handedness)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (_lastGrabs.TryGetValue(handedness, out var value))
			{
				if ((Object)(object)value.Grip == (Object)null)
				{
					_lastGrabs.Remove(handedness);
				}
				else
				{
					Attach(handedness, value.Grip, value.TargetInBase);
				}
			}
		}

		public void CheckDetachAndReattach(Hand hand, Grip grip)
		{
			DelayUtilities.InvokeNextFrame(OnNextFrame);
			void OnNextFrame()
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				if (!ValidateDetach(hand, grip) && (Object)(object)hand.AttachedReceiver != (Object)(object)grip)
				{
					UncullGrip(hand.handedness);
				}
			}
		}

		private bool ValidateDetach(Hand hand, Grip grip)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (IsCulled)
			{
				return true;
			}
			Handedness handedness = hand.handedness;
			if (!_lastGrabs.TryGetValue(handedness, out var value))
			{
				return true;
			}
			if ((Object)(object)value.Grip == (Object)(object)grip)
			{
				return false;
			}
			return true;
		}
	}
	public class RigPhysics
	{
		private readonly MarrowEntity _entity;

		public RigPhysics(RigManager rigManager)
		{
			_entity = rigManager.physicsRig.marrowEntity;
		}

		public void CullPhysics(bool isInactive)
		{
			bool flag = !isInactive;
			_entity.EnableColliders(flag);
		}
	}
	public class RigPose : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 122;

		public SerializedLocalTransform[] TrackedPoints = new SerializedLocalTransform[3];

		public SerializedSmallQuaternion TrackedPlayspace = SerializedSmallQuaternion.Default;

		public Quaternion TrackedPlayspaceExpanded = Quaternion.identity;

		public BodyPose PelvisPose = new BodyPose();

		public SerializedController LeftController;

		public SerializedController RightController;

		public float CrouchTarget;

		public float FeetOffset;

		public float Health = 100f;

		public float MaxHealth = 100f;

		public int? GetSize()
		{
			return 122;
		}

		public void ReadSkeleton(RigSkeleton skeleton)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < 3; i++)
			{
				TrackedPoints[i] = new SerializedLocalTransform(skeleton.TrackedPoints[i]);
			}
			TrackedPlayspaceExpanded = skeleton.TrackedPlayspace.rotation;
			TrackedPlayspace = SerializedSmallQuaternion.Compress(TrackedPlayspaceExpanded);
			PelvisPose.ReadFrom(skeleton.PhysicsPelvis);
			LeftController = new SerializedController(skeleton.PhysicsLeftHand.Controller);
			RightController = new SerializedController(skeleton.PhysicsRightHand.Controller);
			CrouchTarget = skeleton.RemapRig._crouchTarget;
			FeetOffset = skeleton.RemapRig._feetOffset;
			Health = skeleton.Health.curr_Health;
			MaxHealth = skeleton.Health.max_Health;
		}

		public void Serialize(INetSerializer serializer)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < 3; i++)
			{
				SerializedLocalTransform value = TrackedPoints[i];
				NetSerializerExtensions.SerializeValue(serializer, ref value);
				TrackedPoints[i] = value;
			}
			NetSerializerExtensions.SerializeValue(serializer, ref TrackedPlayspace);
			if (serializer.IsReader)
			{
				TrackedPlayspaceExpanded = TrackedPlayspace.Expand();
			}
			NetSerializerExtensions.SerializeValue(serializer, ref PelvisPose);
			NetSerializerExtensions.SerializeValue(serializer, ref LeftController);
			NetSerializerExtensions.SerializeValue(serializer, ref RightController);
			serializer.SerializeValue(ref CrouchTarget);
			serializer.SerializeValue(ref FeetOffset);
			serializer.SerializeValue(ref Health);
			serializer.SerializeValue(ref MaxHealth);
		}
	}
	public class RigPuppet
	{
		[CompilerGenerated]
		private sealed class <WaitAndCallSpawnEffect>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MarrowEntity marrowEntity;

			private float <elapsed>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WaitAndCallSpawnEffect>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<elapsed>5__2 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__2 < 0.2f)
				{
					<elapsed>5__2 += TimeReferences.DeltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if ((Object)(object)marrowEntity == (Object)null)
				{
					return false;
				}
				SpawnEffects.CallSpawnEffect(marrowEntity);
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private RigRefs _selfReferences;

		public bool HasPuppet
		{
			get
			{
				if (_selfReferences != null)
				{
					return _selfReferences.IsValid;
				}
				return false;
			}
		}

		public void CreatePuppet(Action<RigManager> onPuppetCreated = null)
		{
			DestroyPuppet();
			PlayerRepUtilities.CreateNewRig(delegate(RigManager rig)
			{
				OnPuppetCreated(rig, onPuppetCreated);
			});
		}

		private void OnPuppetCreated(RigManager rig, Action<RigManager> onPuppetCreated = null)
		{
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			((Component)rig.physicsRig).gameObject.AddComponent<Poolee>();
			Haptor haptor = rig.ControllerRig.leftController.haptor;
			rig.ControllerRig.leftController = ((Component)rig.ControllerRig.leftController).gameObject.AddComponent<BaseController>();
			rig.ControllerRig.leftController.contRig = rig.ControllerRig;
			haptor.device_Controller = rig.ControllerRig.leftController;
			rig.ControllerRig.leftController.handedness = (Handedness)1;
			Haptor haptor2 = rig.ControllerRig.rightController.haptor;
			rig.ControllerRig.rightController = ((Component)rig.ControllerRig.rightController).gameObject.AddComponent<BaseController>();
			rig.ControllerRig.rightController.contRig = rig.ControllerRig;
			haptor2.device_Controller = rig.ControllerRig.rightController;
			rig.ControllerRig.rightController.handedness = (Handedness)2;
			_selfReferences = new RigRefs(rig);
			InventorySlotReceiver[] rigSlots = _selfReferences.RigSlots;
			for (int i = 0; i < rigSlots.Length; i++)
			{
				foreach (BoxCollider componentsInChild in ((Component)rigSlots[i]).GetComponentsInChildren<BoxCollider>())
				{
					if (((Collider)componentsInChild).isTrigger)
					{
						componentsInChild.size *= 0.4f;
					}
				}
			}
			onPuppetCreated?.Invoke(rig);
			MelonCoroutines.Start(WaitAndCallSpawnEffect(rig.physicsRig.marrowEntity));
		}

		[IteratorStateMachine(typeof(<WaitAndCallSpawnEffect>d__5))]
		private static IEnumerator WaitAndCallSpawnEffect(MarrowEntity marrowEntity)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitAndCallSpawnEffect>d__5(0)
			{
				marrowEntity = marrowEntity
			};
		}

		public void DestroyPuppet()
		{
			if (HasPuppet)
			{
				SpawnEffects.CallDespawnEffect(_selfReferences.RigManager.physicsRig.marrowEntity);
				_selfReferences.LeftHand.TryDetach();
				_selfReferences.RightHand.TryDetach();
				Object.Destroy((Object)(object)((Component)_selfReferences.RigManager).gameObject);
			}
		}
	}
	public class RigSkeleton
	{
		public Transform[] TrackedPoints;

		public Transform TrackedPlayspace;

		public Rigidbody PhysicsPelvis;

		public Hand PhysicsLeftHand;

		public Hand PhysicsRightHand;

		public RemapRig RemapRig;

		public Health Health;

		public RigSkeleton(RigManager rigManager)
		{
			RigAbstractor.FillTransformArray(ref TrackedPoints, rigManager);
			TrackedPlayspace = rigManager.GetSmoothTurnTransform();
			PhysicsRig physicsRig = rigManager.physicsRig;
			PhysicsPelvis = ((Component)((Rig)physicsRig).m_pelvis).GetComponent<Rigidbody>();
			PhysicsLeftHand = physicsRig.leftHand;
			PhysicsRightHand = physicsRig.rightHand;
			RemapRig = rigManager.remapHeptaRig;
			Health = rigManager.health;
		}
	}
	public class RigVoiceSource
	{
		public const float HighFrequency = 25000f;

		private float _occlusionUpdateTimer;

		public GameObject GameObject { get; private set; }

		public Transform Transform { get; private set; }

		public VoiceSource VoiceSource { get; private set; }

		public AudioLowPassFilter LowPassFilter { get; private set; }

		public float Frequency { get; set; } = 25000f;


		public float TargetFrequency { get; set; } = 25000f;


		public float OcclusionMultiplier { get; set; } = 1f;


		public float MinMicrophoneDistance { get; set; } = 1f;


		public float MaxMicrophoneDistance { get; set; } = 30f;


		public Transform Mouth { get; private set; }

		public JawFlapper JawFlapper { get; set; }

		public RigVoiceSource(JawFlapper jawFlapper, Transform mouth)
		{
			JawFlapper = jawFlapper;
			Mouth = mouth;
		}

		public void CreateVoiceSource(int id)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			VoiceSource = VoiceSourceManager.CreateVoiceSource(id);
			GameObject = ((Component)VoiceSource).gameObject;
			Transform = GameObject.transform;
			Transform.parent = Mouth;
			Transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
			LowPassFilter = GameObject.AddComponent<AudioLowPassFilter>();
			LowPassFilter.lowpassResonanceQ = 0.1f;
			LowPassFilter.cutoffFrequency = 25000f;
			VoiceSource.AudioSource.minDistance = MinMicrophoneDistance;
		}

		public void DestroyVoiceSource()
		{
			if (!((Object)(object)GameObject == (Object)null))
			{
				Object.Destroy((Object)(object)GameObject);
			}
		}

		public void UpdateVoiceSource(float distanceSqr, float deltaTime)
		{
			bool flag = distanceSqr > MaxMicrophoneDistance * MaxMicrophoneDistance * 1.2f;
			VoiceSource.Muted = flag;
			if (flag)
			{
				JawFlapper.ClearJaw();
				return;
			}
			JawFlapper.UpdateJaw(VoiceSource.Amplitude, deltaTime);
			UpdateOcclusion(deltaTime);
		}

		public void UpdateOcclusion(float deltaTime)
		{
			_occlusionUpdateTimer += deltaTime;
			if (_occlusionUpdateTimer >= 0.1f)
			{
				_occlusionUpdateTimer = 0f;
				CheckLowPass();
			}
			TargetFrequency = 25000f * OcclusionMultiplier;
			Frequency = ManagedMathf.Lerp(Frequency, TargetFrequency, Smoothing.CalculateDecay(24f, TimeReferences.DeltaTime));
			LowPassFilter.cutoffFrequency = Frequency;
		}

		public void SetVoiceRange(float avatarHeight)
		{
			float x = avatarHeight / 1.76f;
			MinMicrophoneDistance = 3f * MathF.Sqrt(x);
			MaxMicrophoneDistance = 30f * MathF.Sqrt(x);
			if (!((Object)(object)VoiceSource == (Object)null))
			{
				VoiceSource.AudioSource.minDistance = MinMicrophoneDistance;
			}
		}

		private void CheckLowPass()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			OcclusionMultiplier = 1f;
			if (RigData.HasPlayer)
			{
				Vector3 position = RigData.Refs.Headset.position;
				Vector3 position2 = Transform.position;
				OcclusionMultiplier = AudioOcclusion.RaycastOcclusionMultiplier(position, position2);
			}
		}
	}
	public class RigHeadUI
	{
		public const float OffsetHeight = 0.2f;

		private Poolee _layoutPoolee;

		private Transform _layoutTransform;

		private bool _visible = true;

		private readonly HashSet<IPopupLayoutElement> _elements = new HashSet<IPopupLayoutElement>();

		public bool Spawned => (Object)(object)_layoutPoolee != (Object)null;

		public bool Visible
		{
			get
			{
				return _visible;
			}
			set
			{
				_visible = value;
				if (!((Object)(object)_layoutPoolee == (Object)null))
				{
					((Component)_layoutPoolee).gameObject.SetActive(value);
				}
			}
		}

		public void Spawn()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.HeadLayoutReference);
			LocalAssetSpawner.Register(spawnable);
			LocalAssetSpawner.Spawn(spawnable, Vector3.zero, Quaternion.identity, OnSpawned);
		}

		public void Despawn()
		{
			if (!((Object)(object)_layoutPoolee == (Object)null))
			{
				_layoutPoolee.Despawn();
				_layoutPoolee = null;
				_layoutTransform = null;
				DespawnElements();
			}
		}

		public void RegisterElement(IPopupLayoutElement element)
		{
			if (_elements.Add(element) && Spawned)
			{
				element.Spawn(_layoutTransform);
				SortElements();
			}
		}

		public void UnregisterElement(IPopupLayoutElement element)
		{
			if (_elements.Remove(element))
			{
				element.Despawn();
			}
		}

		private void SortElements()
		{
			IOrderedEnumerable<IPopupLayoutElement> source = _elements.OrderBy((IPopupLayoutElement e) => e.Priority);
			for (int i = 0; i < source.Count(); i++)
			{
				Transform transform = source.ElementAt(i).Transform;
				if (Object.op_Implicit((Object)(object)transform))
				{
					transform.SetSiblingIndex(i);
				}
			}
		}

		private void OnSpawned(Poolee poolee)
		{
			_layoutPoolee = poolee;
			_layoutTransform = ((Component)poolee).transform;
			SpawnElements();
			((Component)_layoutPoolee).gameObject.SetActive(Visible);
		}

		private void SpawnElements()
		{
			foreach (IPopupLayoutElement element in _elements)
			{
				element.Spawn(_layoutTransform);
			}
			SortElements();
		}

		private void DespawnElements()
		{
			foreach (IPopupLayoutElement element in _elements)
			{
				element.Despawn();
			}
		}

		public void UpdateScale(RigManager rigManager)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (Spawned)
			{
				Avatar avatar = rigManager.avatar;
				if (Object.op_Implicit((Object)(object)avatar))
				{
					float num = avatar.height / 1.76f;
					_layoutTransform.localScale = Vector3Extensions.one * num;
				}
			}
		}

		public void UpdateTransform(RigManager rigManager)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (Spawned)
			{
				Vector3 val = ((Rig)rigManager.physicsRig).m_head.position + Vector3Extensions.up * GetUIOffset(rigManager);
				Transform head = RigData.Refs.Head;
				Vector3 val2 = val - head.position;
				Quaternion val3 = Quaternion.LookRotation(((Vector3)(ref val2)).normalized, head.up);
				_layoutTransform.SetPositionAndRotation(val, val3);
			}
		}

		public static float GetUIOffset(RigManager rigManager)
		{
			return 0.2f * rigManager.avatar.height;
		}
	}
	public class RigHealthBar : IPopupLayoutElement
	{
		private Poolee _poolee;

		private Transform _transform;

		private Slider _slider;

		private TMP_Text _text;

		private bool _visible = true;

		private float _health = 100f;

		private float _maxHealth = 100f;

		public int Priority => 1000;

		public Transform Transform => _transform;

		public bool Visible
		{
			get
			{
				return _visible;
			}
			set
			{
				_visible = value;
				if (!((Object)(object)_poolee == (Object)null))
				{
					if (value)
					{
						((Component)_poolee).gameObject.SetActive(true);
					}
					else
					{
						((Component)_poolee).gameObject.SetActive(false);
					}
				}
			}
		}

		public float Health
		{
			get
			{
				return _health;
			}
			set
			{
				_health = value;
				UpdateVisuals();
			}
		}

		public float MaxHealth
		{
			get
			{
				return _maxHealth;
			}
			set
			{
				_maxHealth = value;
				UpdateVisuals();
			}
		}

		public float HealthPercent => Health / MaxHealth;

		public void Spawn(Transform parent)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.HealthBarReference);
			LocalAssetSpawner.Register(spawnable);
			LocalAssetSpawner.Spawn(spawnable, Vector3.zero, Quaternion.identity, delegate(Poolee poolee)
			{
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				_poolee = poolee;
				_slider = ((Component)poolee).GetComponentInChildren<Slider>();
				_transform = ((Component)poolee).transform;
				_transform.parent = parent;
				_transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
				((Component)poolee).gameObject.SetActive(Visible);
				_text = ((Component)poolee).GetComponentInChildren<TMP_Text>();
				_text.font = PersistentAssetCreator.Font;
				UpdateVisuals();
			});
		}

		public void Despawn()
		{
			if (!((Object)(object)_poolee == (Object)null))
			{
				_poolee.Despawn();
				_poolee = null;
				_transform = null;
				_slider = null;
			}
		}

		private void UpdateVisuals()
		{
			if ((Object)(object)_slider != (Object)null)
			{
				_slider.value = HealthPercent;
			}
			if ((Object)(object)_text != (Object)null)
			{
				_text.text = $"{Mathf.RoundToInt(Health)}/{Mathf.RoundToInt(MaxHealth)}";
			}
		}
	}
	public class RigIcon : IPopupLayoutElement
	{
		private Transform _iconTransform;

		private Poolee _iconPoolee;

		private RawImage _iconImage;

		private Texture _texture;

		private bool _visible = true;

		public RawImage Image => _iconImage;

		public Texture Texture
		{
			get
			{
				return _texture;
			}
			set
			{
				_texture = value;
				UpdateImage();
			}
		}

		public int Priority => -1000;

		public bool Visible
		{
			get
			{
				return _visible;
			}
			set
			{
				_visible = value;
				if (!((Object)(object)_iconPoolee == (Object)null))
				{
					((Component)_iconPoolee).gameObject.SetActive(value);
				}
			}
		}

		public Transform Transform => _iconTransform;

		public void UpdateImage()
		{
			if (!((Object)(object)Image == (Object)null))
			{
				Image.texture = Texture;
			}
		}

		public void Spawn(Transform parent)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.IconReference);
			LocalAssetSpawner.Register(spawnable);
			LocalAssetSpawner.Spawn(spawnable, Vector3.zero, Quaternion.identity, delegate(Poolee poolee)
			{
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				_iconPoolee = poolee;
				_iconImage = ((Component)poolee).GetComponentInChildren<RawImage>();
				_iconTransform = ((Component)poolee).transform;
				_iconTransform.parent = parent;
				_iconTransform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
				((Component)poolee).gameObject.SetActive(Visible);
				UpdateImage();
			});
		}

		public void Despawn()
		{
			if (!((Object)(object)_iconPoolee == (Object)null))
			{
				_iconPoolee.Despawn();
				_iconPoolee = null;
				_iconImage = null;
				_iconTransform = null;
			}
		}
	}
	public class RigLivesBar : IPopupLayoutElement
	{
		private Poolee _poolee;

		private Transform _transform;

		private GameObject _lifeTemplate;

		private TMP_Text _damageText;

		private readonly List<GameObject> _lifeInstances = new List<GameObject>();

		private bool _visible = true;

		private float _damage;

		private int _lives;

		public int Priority => 500;

		public Transform Transform => _transform;

		public bool Visible
		{
			get
			{
				return _visible;
			}
			set
			{
				_visible = value;
				if (!((Object)(object)_poolee == (Object)null))
				{
					if (value)
					{
						((Component)_poolee).gameObject.SetActive(true);
					}
					else
					{
						((Component)_poolee).gameObject.SetActive(false);
					}
				}
			}
		}

		public float Damage
		{
			get
			{
				return _damage;
			}
			set
			{
				_damage = value;
				UpdateVisuals();
			}
		}

		public int Lives
		{
			get
			{
				return _lives;
			}
			set
			{
				_lives = value;
				UpdateVisuals();
			}
		}

		public void Spawn(Transform parent)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.LivesBarReference);
			LocalAssetSpawner.Register(spawnable);
			LocalAssetSpawner.Spawn(spawnable, Vector3.zero, Quaternion.identity, delegate(Poolee poolee)
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				ClearLifeInstances();
				_poolee = poolee;
				_transform = ((Component)poolee).transform;
				_transform.parent = parent;
				_transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
				((Component)poolee).gameObject.SetActive(Visible);
				_lifeTemplate = ((Component)_transform.Find("Canvas/Icons/Life")).gameObject;
				_lifeTemplate.SetActive(false);
				_damageText = ((Component)poolee).GetComponentInChildren<TMP_Text>();
				_damageText.font = PersistentAssetCreator.Font;
				UpdateVisuals();
			});
		}

		public void Despawn()
		{
			if (!((Object)(object)_poolee == (Object)null))
			{
				_poolee.Despawn();
				_poolee = null;
				_transform = null;
				ClearLifeInstances();
			}
		}

		private void UpdateVisuals()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			CreateLifeInstances(Lives);
			if ((Object)(object)_damageText != (Object)null)
			{
				_damageText.text = $"{Mathf.RoundToInt(Damage)}%";
				((Graphic)_damageText).color = Color.Lerp(Color.white, new Color(0.6f, 0f, 0f, 1f), Damage / 300f);
			}
		}

		private void ClearLifeInstances()
		{
			foreach (GameObject lifeInstance in _lifeInstances)
			{
				if ((Object)(object)lifeInstance != (Object)null)
				{
					Object.Destroy((Object)(object)lifeInstance);
				}
			}
			_lifeInstances.Clear();
		}

		private void CreateLifeInstances(int count)
		{
			if (count != _lifeInstances.Count && !((Object)(object)_lifeTemplate == (Object)null))
			{
				ClearLifeInstances();
				for (int i = 0; i < count; i++)
				{
					GameObject val = Object.Instantiate<GameObject>(_lifeTemplate, _lifeTemplate.transform.parent, false);
					val.transform.SetSiblingIndex(i);
					val.SetActive(true);
					_lifeInstances.Add(val);
				}
			}
		}
	}
	public class RigNameTag : IPopupLayoutElement
	{
		private Transform _nametagTransform;

		private Poolee _nametagPoolee;

		private TextMeshProUGUI _nametagText;

		private GameObject _crownGameObject;

		private Color _color = Color.white;

		private string _username = "No Name";

		private bool _visible = true;

		private bool _crownVisible;

		public TextMeshProUGUI Text => _nametagText;

		public Color Color
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _color;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				_color = value;
				if (!((Object)(object)Text == (Object)null))
				{
					((Graphic)Text).color = value;
				}
			}
		}

		public string Username
		{
			get
			{
				return _username;
			}
			set
			{
				_username = value;
				UpdateText();
			}
		}

		public int Priority => 0;

		public bool Visible
		{
			get
			{
				return _visible;
			}
			set
			{
				_visible = value;
				if (!((Object)(object)_nametagPoolee == (Object)null))
				{
					((Component)_nametagPoolee).gameObject.SetActive(value);
				}
			}
		}

		public bool CrownVisible
		{
			get
			{
				return _crownVisible;
			}
			set
			{
				_crownVisible = value;
				if (!((Object)(object)_crownGameObject == (Object)null))
				{
					_crownGameObject.SetActive(value);
				}
			}
		}

		public Transform Transform => _nametagTransform;

		public void UpdateText()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Text == (Object)null))
			{
				((TMP_Text)Text).text = _username.RemoveRichTextExceptColor();
				((Graphic)Text).color = Color;
			}
		}

		public void Spawn(Transform parent)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.NameTagReference);
			LocalAssetSpawner.Register(spawnable);
			LocalAssetSpawner.Spawn(spawnable, Vector3.zero, Quaternion.identity, delegate(Poolee poolee)
			{
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				_nametagPoolee = poolee;
				_nametagText = ((Component)poolee).GetComponentInChildren<TextMeshProUGUI>();
				_nametagTransform = ((Component)poolee).transform;
				_nametagTransform.parent = parent;
				_nametagTransform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
				((Component)poolee).gameObject.SetActive(Visible);
				((TMP_Text)_nametagText).font = PersistentAssetCreator.Font;
				GetIcons(((TMP_Text)_nametagText).transform);
				UpdateText();
			});
		}

		public void Despawn()
		{
			if (!((Object)(object)_nametagPoolee == (Object)null))
			{
				_nametagPoolee.Despawn();
				_nametagPoolee = null;
				_nametagText = null;
				_nametagTransform = null;
			}
		}

		private void GetIcons(Transform textTransform)
		{
			Transform val = textTransform.Find("Icons");
			if (!((Object)(object)val == (Object)null))
			{
				Transform val2 = val.Find("Crown");
				if ((Object)(object)val2 != (Object)null)
				{
					_crownGameObject = ((Component)val2).gameObject;
					_crownGameObject.SetActive(CrownVisible);
				}
			}
		}
	}
	public class RigProgressBar : IPopupLayoutElement, IProgress<float>
	{
		[CompilerGenerated]
		private sealed class <CoDelayedDisable>d__14 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public float time;

			public RigProgressBar <>4__this;

			private float <elapsed>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <CoDelayedDisable>d__14(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				RigProgressBar rigProgressBar = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<elapsed>5__2 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__2 < time)
				{
					<elapsed>5__2 += TimeReferences.DeltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if ((Object)(object)rigProgressBar._poolee != (Object)null)
				{
					((Component)rigProgressBar._poolee).gameObject.SetActive(false);
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private const string _visibilityParameterName = "Visible";

		private Poolee _poolee;

		private Transform _transform;

		private Slider _slider;

		private TMP_Text _text;

		private Animator _animator;

		private bool _visible = true;

		private float _progress;

		public int Priority => 10000;

		public Transform Transform => _transform;

		public bool Visible
		{
			get
			{
				return _visible;
			}
			set
			{
				_visible = value;
				if (!((Object)(object)_poolee == (Object)null))
				{
					if (value)
					{
						((Component)_poolee).gameObject.SetActive(true);
					}
					else
					{
						MelonCoroutines.Start(CoDelayedDisable(1.2f));
					}
					_animator.SetBool("Visible", Visible);
				}
			}
		}

		[IteratorStateMachine(typeof(<CoDelayedDisable>d__14))]
		private IEnumerator CoDelayedDisable(float time)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoDelayedDisable>d__14(0)
			{
				<>4__this = this,
				time = time
			};
		}

		public void Spawn(Transform parent)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Spawnable spawnable = LocalAssetSpawner.CreateSpawnable(FusionSpawnableReferences.ProgressBarReference);
			LocalAssetSpawner.Register(spawnable);
			LocalAssetSpawner.Spawn(spawnable, Vector3.zero, Quaternion.identity, delegate(Poolee poolee)
			{
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				_poolee = poolee;
				_animator = ((Component)poolee).GetComponent<Animator>();
				_slider = ((Component)poolee).GetComponentInChildren<Slider>();
				_transform = ((Component)poolee).transform;
				_transform.parent = parent;
				_transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
				((Component)poolee).gameObject.SetActive(Visible);
				_text = ((Component)poolee).GetComponentInChildren<TMP_Text>();
				_text.font = PersistentAssetCreator.Font;
				UpdateVisuals();
			});
		}

		public void Despawn()
		{
			if (!((Object)(object)_poolee == (Object)null))
			{
				_poolee.Despawn();
				_poolee = null;
				_animator = null;
				_transform = null;
				_slider = null;
			}
		}

		public void Report(float value)
		{
			_progress = value;
			UpdateVisuals();
		}

		private void UpdateVisuals()
		{
			if ((Object)(object)_slider != (Object)null)
			{
				_slider.value = _progress;
			}
			if ((Object)(object)_text != (Object)null)
			{
				_text.text = $"{Mathf.RoundToInt(_progress * 100f)}%";
			}
			if ((Object)(object)_animator != (Object)null)
			{
				_animator.SetBool("Visible", Visible);
			}
		}
	}
	public class BodyPose : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 28;

		public Vector3 Position = Vector3.zero;

		public Quaternion Rotation = Quaternion.identity;

		public Vector3 Velocity = Vector3.zero;

		public Vector3 AngularVelocity = Vector3.zero;

		private Vector3 _positionPrediction = Vector3.zero;

		public Vector3 PredictedPosition => Position + _positionPrediction;

		public int? GetSize()
		{
			return 28;
		}

		public void ReadFrom(Rigidbody rigidbody)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			Position = rigidbody.position;
			Rotation = rigidbody.rotation;
			Velocity = rigidbody.velocity;
			AngularVelocity = rigidbody.angularVelocity;
		}

		public void CopyTo(BodyPose target)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			target.Position = Position;
			target.Rotation = Rotation;
			target.Velocity = Velocity;
			target.AngularVelocity = AngularVelocity;
			target.ResetPrediction();
		}

		public void ResetPrediction()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			_positionPrediction = Vector3.zero;
		}

		public void PredictPosition(float deltaTime)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			_positionPrediction += Velocity * deltaTime;
		}

		public void Serialize(INetSerializer serializer)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			SerializedShortVector3 value = null;
			SerializedSmallQuaternion value2 = null;
			SerializedSmallVector3 value3 = null;
			SerializedSmallVector3 value4 = null;
			if (!serializer.IsReader)
			{
				value = SerializedShortVector3.Compress(Position);
				value2 = SerializedSmallQuaternion.Compress(Rotation);
				value3 = SerializedSmallVector3.Compress(Velocity);
				value4 = SerializedSmallVector3.Compress(AngularVelocity);
			}
			NetSerializerExtensions.SerializeValue(serializer, ref value);
			NetSerializerExtensions.SerializeValue(serializer, ref value2);
			NetSerializerExtensions.SerializeValue(serializer, ref value3);
			NetSerializerExtensions.SerializeValue(serializer, ref value4);
			if (serializer.IsReader)
			{
				Position = value.Expand();
				Rotation = value2.Expand();
				Velocity = value3.Expand();
				AngularVelocity = value4.Expand();
			}
		}
	}
	public class EntityPose : LabFusion.Network.Serialization.INetSerializable
	{
		public BodyPose[] Bodies;

		public int? GetSize()
		{
			return 1 + 28 * Bodies.Length;
		}

		public EntityPose()
		{
		}

		public EntityPose(int bodyCount)
		{
			Bodies = new BodyPose[bodyCount];
			for (int i = 0; i < bodyCount; i++)
			{
				Bodies[i] = new BodyPose();
			}
		}

		public void CopyTo(EntityPose target)
		{
			if (target.Bodies.Length == Bodies.Length)
			{
				for (int i = 0; i < target.Bodies.Length; i++)
				{
					Bodies[i].CopyTo(target.Bodies[i]);
				}
			}
		}

		public void ResetPrediction()
		{
			BodyPose[] bodies = Bodies;
			for (int i = 0; i < bodies.Length; i++)
			{
				bodies[i].ResetPrediction();
			}
		}

		public void Serialize(INetSerializer serializer)
		{
			if (serializer is NetWriter writer)
			{
				Serialize(writer);
			}
			else if (serializer is NetReader reader)
			{
				Deserialize(reader);
			}
		}

		public void Serialize(NetWriter writer)
		{
			byte b = (byte)Bodies.Length;
			writer.Write(b);
			for (int i = 0; i < b; i++)
			{
				NetSerializerExtensions.SerializeValue(writer, ref Bodies[i]);
			}
		}

		public void Deserialize(NetReader reader)
		{
			byte b = reader.ReadByte();
			Bodies = new BodyPose[b];
			for (int i = 0; i < b; i++)
			{
				NetSerializerExtensions.SerializeValue(reader, ref Bodies[i]);
			}
		}
	}
	public class NetworkProp : IEntityExtender, IMarrowEntityExtender, IEntityUpdatable, IEntityFixedUpdatable
	{
		private NetworkEntity _networkEntity;

		private MarrowEntity _marrowEntity;

		private MarrowBody[] _bodies;

		private PDController[] _pdControllers;

		private EntityPose _pose;

		private EntityPose _sentPose;

		private bool _receivedPose;

		private float _lastReceivedTime;

		private float _ownerSleepElapsed;

		private DestroySensor _destroySensor;

		private static int _globalSleepOffset;

		private int _sleepFrameOffset;

		private const int _sleepCheckInterval = 20;

		private HashSet<IEntityComponentExtender> _componentExtenders;

		public const float MinMoveMagnitude = 0.005f;

		public const float MinMoveSqrMagnitude = 2.5E-05f;

		public const float MinMoveAngle = 0.15f;

		public const float SleepTimer = 0.5f;

		private Action _onReadyCallback;

		public NetworkEntity NetworkEntity => _networkEntity;

		public MarrowEntity MarrowEntity => _marrowEntity;

		public bool IsSleeping { get; private set; }

		public bool IsFrozen { get; private set; }

		public bool InitialCull { get; private set; }

		public bool IsCulled { get; private set; }

		public bool IsCulledForOwner { get; private set; }

		public EntityPose EntityPose => _pose;

		public NetworkProp(NetworkEntity networkEntity, MarrowEntity marrowEntity)
		{
			_networkEntity = networkEntity;
			_marrowEntity = marrowEntity;
			InitializeBodies();
			InitializeComponents();
			IMarrowEntityExtender.Cache.Add(marrowEntity, networkEntity);
			networkEntity.HookOnRegistered(OnPropRegistered);
			networkEntity.OnEntityUnregistered += OnPropUnregistered;
		}

		private void OnEntityOwnershipTransfer(NetworkEntity entity, PlayerID player)
		{
			_receivedPose = false;
			if (entity.IsOwner)
			{
				Unfreeze();
				IsCulledForOwner = IsCulled;
				SendCullStatus(IsCulled, CommonMessageRoutes.ReliableToOtherClients);
			}
			OnReregisterUpdates();
		}

		private void OnEntityDataCatchup(NetworkEntity entity, PlayerID player)
		{
			MessageRoute route = new MessageRoute(player.SmallID, NetworkChannel.Reliable);
			SendEntityPose(route);
			SendCullStatus(IsCulled, route);
		}

		private void InitializeBodies()
		{
			_bodies = Il2CppArrayBase<MarrowBody>.op_Implicit((Il2CppArrayBase<MarrowBody>)(object)MarrowEntity.Bodies);
			_pose = new EntityPose(_bodies.Length);
			_sentPose = new EntityPose(_bodies.Length);
			_pdControllers = new PDController[_bodies.Length];
			for (int i = 0; i < _pdControllers.Length; i++)
			{
				_pdControllers[i] = new PDController();
			}
			CopyBodiesToPose();
			UpdateReceiveTime();
		}

		private void InitializeComponents()
		{
			_componentExtenders = EntityComponentManager.ApplyComponents(NetworkEntity, ((Component)MarrowEntity).gameObject);
		}

		public void OnReceivePose(EntityPose pose)
		{
			pose.CopyTo(EntityPose);
			UpdateReceiveTime();
		}

		public void OnReceiveCullStatus(bool isCulled)
		{
			IsCulledForOwner = isCulled;
		}

		private void UpdateReceiveTime()
		{
			Unfreeze();
			_receivedPose = true;
			_lastReceivedTime = TimeReferences.TimeSinceStartup;
		}

		public void ResetPrediction()
		{
			EntityPose.ResetPrediction();
		}

		public void TeleportToPose()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < _bodies.Length; i++)
			{
				MarrowBody val = _bodies[i];
				if (val.HasRigidbody)
				{
					Rigidbody rigidbody = val._rigidbody;
					if (!rigidbody.isKinematic)
					{
						Transform transform = ((Component)rigidbody).transform;
						BodyPose bodyPose = EntityPose.Bodies[i];
						transform.position = bodyPose.PredictedPosition;
						transform.rotation = bodyPose.Rotation;
						rigidbody.velocity = bodyPose.Velocity;
						rigidbody.angularVelocity = bodyPose.AngularVelocity;
					}
				}
			}
		}

		private void CopyBodiesToPose()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			_receivedPose = false;
			for (int i = 0; i < _bodies.Length; i++)
			{
				MarrowBody val = _bodies[i];
				if (val.HasRigidbody)
				{
					BodyPose obj = _pose.Bodies[i];
					Rigidbody rigidbody = val._rigidbody;
					obj.Position = rigidbody.position;
					obj.Rotation = rigidbody.rotation;
					obj.Velocity = rigidbody.velocity;
					obj.AngularVelocity = rigidbody.angularVelocity;
					obj.ResetPrediction();
				}
			}
		}

		private bool IsMarrowEntityDestroyed()
		{
			if (!((Object)(object)MarrowEntity == (Object)null) && !MarrowEntity.IsDestroyed)
			{
				return MarrowEntity.IsDespawned;
			}
			return true;
		}

		private void OnPropRegistered(NetworkEntity entity)
		{
			if (IsMarrowEntityDestroyed())
			{
				OnSensorDestroyed();
				return;
			}
			entity.ConnectExtender(this);
			entity.OnEntityOwnershipTransfer = (NetworkEntityPlayerDelegate)Delegate.Combine(entity.OnEntityOwnershipTransfer, new NetworkEntityPlayerDelegate(OnEntityOwnershipTransfer));
			entity.OnEntityDataCatchup += OnEntityDataCatchup;
			OnReregisterUpdates();
			AddDestroySensor();
			OnEntityCull(MarrowEntity.IsCulled);
			InitialCull = true;
			_sleepFrameOffset = _globalSleepOffset;
			_globalSleepOffset++;
			if (_globalSleepOffset >= 30)
			{
				_globalSleepOffset = 0;
			}
			_onReadyCallback?.InvokeSafe("executing NetworkProp.OnReadyCallback");
			_onReadyCallback = null;
		}

		private void OnPropUnregistered(NetworkEntity entity)
		{
			Unfreeze();
			IMarrowEntityExtender.Cache.Remove(MarrowEntity);
			entity.DisconnectExtender(this);
			entity.OnEntityOwnershipTransfer = (NetworkEntityPlayerDelegate)Delegate.Remove(entity.OnEntityOwnershipTransfer, new NetworkEntityPlayerDelegate(OnEntityOwnershipTransfer));
			entity.OnEntityDataCatchup -= OnEntityDataCatchup;
			_networkEntity = null;
			_marrowEntity = null;
			RemoveDestroySensor();
			OnUnregisterUpdates();
		}

		private void AddDestroySensor()
		{
			_destroySensor = ((Component)MarrowEntity).gameObject.AddComponent<DestroySensor>();
			_destroySensor.Hook(OnSensorDestroyed);
		}

		private void RemoveDestroySensor()
		{
			if ((Object)(object)_destroySensor != (Object)null)
			{
				Object.Destroy((Object)(object)_destroySensor);
			}
		}

		private void OnSensorDestroyed()
		{
			if (NetworkEntity != null && NetworkEntity.IsRegistered)
			{
				NetworkEntityManager.IDManager.UnregisterEntity(NetworkEntity);
			}
			_destroySensor = null;
		}

		public void OnEntityUpdate(float deltaTime)
		{
			OnOwnedUpdate(deltaTime);
		}

		private bool HasBodyMoved(int index)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			BodyPose bodyPose = _pose.Bodies[index];
			BodyPose bodyPose2 = _sentPose.Bodies[index];
			Vector3 val = bodyPose2.Position - bodyPose.Position;
			if (!(((Vector3)(ref val)).sqrMagnitude > 2.5E-05f))
			{
				return Quaternion.Angle(bodyPose2.Rotation, bodyPose.Rotation) > 0.15f;
			}
			return true;
		}

		public void Freeze()
		{
			IsSleeping = true;
			if (!IsFrozen)
			{
				IsFrozen = true;
				if ((Object)(object)MarrowEntity != (Object)null)
				{
					MarrowEntity.Hibernate(true, (HibernationSources)1);
				}
			}
		}

		public void Unfreeze()
		{
			IsSleeping = false;
			if (IsFrozen)
			{
				IsFrozen = false;
				if ((Object)(object)MarrowEntity != (Object)null)
				{
					MarrowEntity.Hibernate(false, (HibernationSources)1);
				}
			}
		}

		private bool CheckOwnedSleeping()
		{
			for (int i = 0; i < _bodies.Length; i++)
			{
				MarrowBody val = _bodies[i];
				if (val.HasRigidbody)
				{
					Rigidbody rigidbody = val._rigidbody;
					if (!rigidbody.isKinematic && !rigidbody.IsSleeping() && HasBodyMoved(i))
					{
						return false;
					}
				}
			}
			return true;
		}

		private void OnOwnedUpdate(float deltaTime)
		{
			if (IsSleeping && !TimeReferences.IsMatchingFrame(20, _sleepFrameOffset))
			{
				return;
			}
			CopyBodiesToPose();
			bool isSleeping = IsSleeping;
			bool flag = CheckOwnedSleeping();
			if (isSleeping && flag)
			{
				return;
			}
			if (isSleeping && !flag)
			{
				_ownerSleepElapsed = 0f;
				IsSleeping = false;
			}
			if (!isSleeping && flag)
			{
				_ownerSleepElapsed += deltaTime;
				if (_ownerSleepElapsed >= 0.5f)
				{
					IsSleeping = flag;
					_ownerSleepElapsed = 0f;
					SendEntityPose(CommonMessageRoutes.ReliableToOtherClients);
					return;
				}
			}
			if (NetworkTickManager.IsTickThisFrame)
			{
				SendEntityPose(CommonMessageRoutes.UnreliableToOtherClients);
			}
		}

		private void SendEntityPose(MessageRoute route)
		{
			MessageRelay.RelayNative(new EntityPoseUpdateData
			{
				Entity = new NetworkEntityReference(NetworkEntity),
				Pose = EntityPose
			}, NativeMessageTag.EntityPoseUpdate, route);
			EntityPose.CopyTo(_sentPose);
		}

		private void SendCullStatus(bool isCulled, MessageRoute route)
		{
			MessageRelay.RelayNative(new EntityCullStatusData
			{
				Entity = new NetworkEntityReference(NetworkEntity),
				IsCulled = isCulled
			}, NativeMessageTag.EntityCullStatus, route);
		}

		public void OnEntityFixedUpdate(float deltaTime)
		{
			OnReceivedUpdate(deltaTime);
		}

		private void OnReceivedUpdate(float deltaTime)
		{
			if (IsSleeping || !_receivedPose)
			{
				return;
			}
			float num = TimeReferences.TimeSinceStartup - _lastReceivedTime;
			if (num >= 0.5f)
			{
				ResetPrediction();
				TeleportToPose();
				Freeze();
			}
			else
			{
				for (int i = 0; i < _bodies.Length; i++)
				{
					OnReceivedRigidbody(deltaTime, num, i);
				}
			}
		}

		private void OnReceivedRigidbody(float deltaTime, float timeSinceMessage, int index)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			MarrowBody val = _bodies[index];
			PDController pDController = _pdControllers[index];
			if (!val.HasRigidbody)
			{
				pDController.Reset();
				return;
			}
			Rigidbody rigidbody = val._rigidbody;
			if (rigidbody.isKinematic)
			{
				pDController.Reset();
				return;
			}
			BodyPose bodyPose = EntityPose.Bodies[index];
			if (timeSinceMessage <= 0.6f)
			{
				bodyPose.PredictPosition(deltaTime);
			}
			Vector3 position = rigidbody.position;
			Vector3 velocity = rigidbody.velocity;
			Vector3 targetPos = bodyPose.PredictedPosition;
			pDController.SavedForce = pDController.GetForce(in position, in velocity, in targetPos, in bodyPose.Velocity);
			rigidbody.AddForce(pDController.SavedForce, (ForceMode)5);
			if (!rigidbody.freezeRotation)
			{
				Quaternion rotation = rigidbody.rotation;
				position = rigidbody.angularVelocity;
				pDController.SavedTorque = pDController.GetTorque(in rotation, in position, in bodyPose.Rotation, in bodyPose.AngularVelocity);
				rigidbody.AddTorque(pDController.SavedTorque, (ForceMode)5);
			}
		}

		public void OnEntityCull(bool isInactive)
		{
			IsCulled = isInactive;
			bool isOwner = NetworkEntity.IsOwner;
			bool hasOwner = NetworkEntity.HasOwner;
			if (isOwner)
			{
				IsCulledForOwner = IsCulled;
				SendCullStatus(IsCulled, CommonMessageRoutes.ReliableToOtherClients);
			}
			if (isInactive)
			{
				OnUnregisterUpdates();
				return;
			}
			OnReregisterUpdates();
			if (!isOwner && hasOwner)
			{
				TeleportToPose();
				TryTakeUncullOwnership();
			}
		}

		private void TryTakeUncullOwnership()
		{
			if (InitialCull && !IsCulled && IsCulledForOwner && !NetworkEntity.IsOwnerLocked)
			{
				NetworkEntityManager.TakeOwnership(NetworkEntity);
			}
		}

		private void OnReregisterUpdates()
		{
			OnUnregisterUpdates();
			if (!IsCulled)
			{
				if (NetworkEntity.IsOwner)
				{
					NetworkEntityManager.UpdatableManager.UpdateManager.Register(this);
				}
				else
				{
					NetworkEntityManager.UpdatableManager.FixedUpdateManager.Register(this);
				}
			}
		}

		private void OnUnregisterUpdates()
		{
			NetworkEntityManager.UpdatableManager.UpdateManager.Unregister(this);
			NetworkEntityManager.UpdatableManager.FixedUpdateManager.Unregister(this);
		}

		public void HookOnReady(Action callback)
		{
			if ((Object)(object)MarrowEntity != (Object)null && NetworkEntity.IsRegistered)
			{
				callback();
			}
			else
			{
				_onReadyCallback = (Action)Delegate.Combine(_onReadyCallback, callback);
			}
		}
	}
	public class RigRefs
	{
		private Action _onDestroyCallback;

		public bool IsValid { get; private set; }

		public RigManager RigManager { get; private set; }

		public ControllerRig ControllerRig { get; private set; }

		public Player_Health Health { get; private set; }

		public Grip[] RigGrips { get; private set; }

		public InventorySlotReceiver[] RigSlots { get; private set; }

		public Hand LeftHand { get; private set; }

		public Hand RightHand { get; private set; }

		public TriggerRefProxy Proxy { get; private set; }

		public Transform Head { get; private set; }

		public Transform Mouth { get; private set; }

		public Transform Headset { get; private set; }

		public void HookOnDestroy(Action callback)
		{
			if (IsValid)
			{
				_onDestroyCallback = (Action)Delegate.Combine(_onDestroyCallback, callback);
			}
			else
			{
				_onDestroyCallback?.Invoke();
			}
		}

		public void OnDestroy()
		{
			IsValid = false;
			_onDestroyCallback?.Invoke();
		}

		public Hand GetHand(Handedness handedness)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)handedness != 1)
			{
				if ((int)handedness == 2)
				{
					return RightHand;
				}
				return null;
			}
			return LeftHand;
		}

		public void DisableInteraction()
		{
			if (RigGrips == null)
			{
				return;
			}
			Grip[] rigGrips = RigGrips;
			foreach (Grip val in rigGrips)
			{
				foreach (Hand item in val.attachedHands.ToArray())
				{
					if (item.manager.IsLocalPlayer())
					{
						val.TryDetach(item);
					}
				}
				((HandReciever)val).DisableInteraction();
			}
			DelayUtilities.InvokeDelayed(Internal_DelayedEnableInteraction, 300);
		}

		private void Internal_DelayedEnableInteraction()
		{
			if (RigGrips != null)
			{
				Grip[] rigGrips = RigGrips;
				for (int i = 0; i < rigGrips.Length; i++)
				{
					((HandReciever)rigGrips[i]).EnableInteraction();
				}
			}
		}

		public RigRefs()
		{
		}

		public RigRefs(RigManager rigManager)
		{
			RigManager = rigManager;
			IsValid = true;
			((Component)rigManager).gameObject.AddComponent<DestroySensor>().Hook(OnDestroy);
			ControllerRig = rigManager.ControllerRig;
			Health = ((Il2CppObjectBase)RigManager.health).Cast<Player_Health>();
			RigGrips = Il2CppArrayBase<Grip>.op_Implicit(((Component)rigManager.physicsRig).GetComponentsInChildren<Grip>(true));
			RigSlots = Il2CppArrayBase<InventorySlotReceiver>.op_Implicit(((Component)rigManager).GetComponentsInChildren<InventorySlotReceiver>(true));
			LeftHand = ((Component)((Rig)rigManager.physicsRig).m_handLf).GetComponent<Hand>();
			RightHand = ((Component)((Rig)rigManager.physicsRig).m_handRt).GetComponent<Hand>();
			Proxy = ((Component)rigManager).GetComponentInChildren<TriggerRefProxy>(true);
			Head = ((Rig)RigManager.physicsRig).m_head;
			Mouth = ((Component)RigManager.physicsRig.headSfx.mouthSrc).transform;
			OpenControllerRig val = ((Il2CppObjectBase)ControllerRig).TryCast<OpenControllerRig>();
			if ((Object)(object)val != (Object)null)
			{
				Headset = val.headset;
			}
			else
			{
				Headset = ((Rig)ControllerRig).m_head;
			}
		}
	}
	public class EntityValidationList
	{
		private readonly HashSet<IEntityValidator> _validators = new HashSet<IEntityValidator>();

		public HashSet<IEntityValidator> Validators => _validators;

		public void Register(IEntityValidator validator)
		{
			if (!_validators.Contains(validator))
			{
				_validators.Add(validator);
			}
		}

		public void Unregister(IEntityValidator validator)
		{
			_validators.Remove(validator);
		}

		public bool Validate(NetworkEntity entity, PlayerID player)
		{
			foreach (IEntityValidator validator in Validators)
			{
				if (!validator.Validate(entity, player))
				{
					return false;
				}
			}
			return true;
		}
	}
	public interface IEntityValidator
	{
		bool Validate(NetworkEntity entity, PlayerID player);
	}
}
namespace LabFusion.Downloading
{
	public delegate void DownloadCallback(DownloadCallbackInfo info);
	public struct DownloadCallbackInfo
	{
		public static readonly DownloadCallbackInfo FailedCallback = new DownloadCallbackInfo
		{
			Pallet = null,
			Result = ModResult.FAILED
		};

		public static readonly DownloadCallbackInfo CanceledCallback = new DownloadCallbackInfo
		{
			Pallet = null,
			Result = ModResult.CANCELED
		};

		public Pallet Pallet;

		public ModResult Result;
	}
	public static class DownloadNotifications
	{
		public const string NotificationTag = "Download";

		public static void SendDownloadNotification(string palletTitle)
		{
			if (ClientSettings.Downloading.NotifyDownloads.Value)
			{
				Notifier.Cancel("Download");
				Notifier.Send(new Notification
				{
					ShowPopup = true,
					SaveToMenu = false,
					Title = "Download Completed",
					Tag = "Download",
					Type = NotificationType.SUCCESS,
					PopupLength = 4f,
					Message = "Finished installing " + palletTitle + "!"
				});
			}
		}
	}
	public static class ModDownloadManager
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass15_0
		{
			public string path;

			public string extractedDirectory;
		}

		[CompilerGenerated]
		private sealed class <CoLoadPalletFromZip>d__15 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string path;

			private <>c__DisplayClass15_0 <>8__1;

			public DownloadCallback downloadCallback;

			public Action scheduledCallback;

			public bool temporary;

			public ModIOFile modFile;

			private Task <unzipTask>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <CoLoadPalletFromZip>d__15(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<unzipTask>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0247: Unknown result type (might be due to invalid IL or missing references)
				//IL_024e: Expected O, but got Unknown
				//IL_024e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0253: Unknown result type (might be due to invalid IL or missing references)
				//IL_025f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0271: Unknown result type (might be due to invalid IL or missing references)
				//IL_028e: Expected O, but got Unknown
				//IL_029c: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02af: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c7: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass15_0();
					<>8__1.path = path;
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(<>8__1.path);
					<>8__1.extractedDirectory = ExportPath + "/" + fileNameWithoutExtension;
					if (Directory.Exists(<>8__1.extractedDirectory))
					{
						Directory.Delete(<>8__1.extractedDirectory, recursive: true);
					}
					Directory.CreateDirectory(<>8__1.extractedDirectory);
					<unzipTask>5__2 = Task.Run((Action)UnzipMod);
					break;
				}
				case 1:
					<>1__state = -1;
					break;
				}
				if (!<unzipTask>5__2.IsCompleted)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if (!<unzipTask>5__2.IsCompletedSuccessfully)
				{
					FusionLogger.LogException("unzipping mod at path " + <>8__1.path, <unzipTask>5__2.Exception);
					downloadCallback?.Invoke(DownloadCallbackInfo.FailedCallback);
					scheduledCallback?.Invoke();
					return false;
				}
				string text = FindPalletJson(<>8__1.extractedDirectory);
				if (string.IsNullOrWhiteSpace(text))
				{
					FusionLogger.Warn("Failed to find pallet json at " + <>8__1.extractedDirectory + ", aborting download!");
					downloadCallback?.Invoke(DownloadCallbackInfo.FailedCallback);
					scheduledCallback?.Invoke();
					return false;
				}
				string directoryName = Path.GetDirectoryName(text);
				if (string.IsNullOrWhiteSpace(directoryName))
				{
					FusionLogger.Warn("Failed to get directory name of pallet " + text + ", aborting download!");
					downloadCallback?.Invoke(DownloadCallbackInfo.FailedCallback);
					scheduledCallback?.Invoke();
					return false;
				}
				DirectoryInfo directoryInfo = new DirectoryInfo(directoryName);
				string text2 = ModsPath;
				if (temporary)
				{
					text2 = ModsTempPath;
				}
				string text3 = text2 + "/" + directoryInfo.Name;
				if (Directory.Exists(text3))
				{
					Directory.Delete(text3, recursive: true);
				}
				Directory.Move(directoryName, text3);
				Directory.Delete(<>8__1.extractedDirectory, recursive: true);
				string palletPath = FindPalletJson(text3);
				StringModTargetListingDictionary val = new StringModTargetListingDictionary();
				ModIOModTarget val2 = new ModIOModTarget
				{
					GameId = ModIOSettings.GameID,
					ModId = modFile.ModID,
					ModfileId = modFile.FileID.Value
				};
				((Dictionary<string, ModTarget>)(object)val).Add(ModIOManager.GetActivePlatform(), (ModTarget)(object)val2);
				ModListing modListing = new ModListing
				{
					Author = null,
					Barcode = null,
					Description = null,
					Repository = null,
					Targets = val
				};
				ModForklift.PalletShipment shipment = default(ModForklift.PalletShipment);
				shipment.palletPath = palletPath;
				shipment.modListing = modListing;
				shipment.callback = downloadCallback;
				ModForklift.SchedulePalletLoad(shipment);
				scheduledCallback?.Invoke();
				return false;
				void UnzipMod()
				{
					using ZipArchive source = ZipFile.OpenRead(((<>c__DisplayClass15_0)this).path);
					source.ExtractToDirectory(((<>c__DisplayClass15_0)this).extractedDirectory, overwriteFiles: true);
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private const string _palletExtension = ".pallet.json";

		public static string ModsPath => Application.persistentDataPath + "/Mods";

		public static string ModsTempPath => Application.persistentDataPath + "/ModsTemp";

		public static string StagingPath => Application.persistentDataPath + "/FusionStaging";

		public static string DownloadPath => StagingPath + "/Downloads";

		public static string ExportPath => StagingPath + "/Exports";

		public static void DeleteTemporaryDirectories()
		{
			if (Directory.Exists(ModsTempPath))
			{
				Directory.Delete(ModsTempPath, recursive: true);
			}
		}

		public static void ValidateDirectories()
		{
			if (!Directory.Exists(StagingPath))
			{
				Directory.CreateDirectory(StagingPath);
			}
			if (!Directory.Exists(ModsTempPath))
			{
				Directory.CreateDirectory(ModsTempPath);
			}
			if (!Directory.Exists(DownloadPath))
			{
				Directory.CreateDirectory(DownloadPath);
			}
			if (!Directory.Exists(ExportPath))
			{
				Directory.CreateDirectory(ExportPath);
			}
		}

		public static string FindPalletJson(string directory)
		{
			string[] files = Directory.GetFiles(directory);
			foreach (string text in files)
			{
				if (text.EndsWith(".pallet.json"))
				{
					return text;
				}
			}
			files = Directory.GetDirectories(directory);
			for (int i = 0; i < files.Length; i++)
			{
				string text2 = FindPalletJson(files[i]);
				if (!string.IsNullOrEmpty(text2))
				{
					return text2;
				}
			}
			return string.Empty;
		}

		public static void LoadPalletFromZip(string path, ModIOFile modFile, bool temporary, Action scheduledCallback = null, DownloadCallback downloadCallback = null)
		{
			MelonCoroutines.Start(CoLoadPalletFromZip(path, modFile, temporary, scheduledCallback, downloadCallback));
		}

		[IteratorStateMachine(typeof(<CoLoadPalletFromZip>d__15))]
		private static IEnumerator CoLoadPalletFromZip(string path, ModIOFile modFile, bool temporary, Action scheduledCallback = null, DownloadCallback downloadCallback = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoLoadPalletFromZip>d__15(0)
			{
				path = path,
				modFile = modFile,
				temporary = temporary,
				scheduledCallback = scheduledCallback,
				downloadCallback = downloadCallback
			};
		}
	}
	public static class ModForklift
	{
		public struct PalletShipment
		{
			public string palletPath;

			public ModListing modListing;

			public DownloadCallback callback;

			public override readonly int GetHashCode()
			{
				return palletPath.GetHashCode();
			}
		}

		private static readonly Queue<PalletShipment> _scheduledShipments = new Queue<PalletShipment>();

		public static void UpdateForklift()
		{
			if (AssetWarehouse.ready && _scheduledShipments.Count > 0)
			{
				LoadPallet(_scheduledShipments.Dequeue());
			}
		}

		private static void LoadPallet(PalletShipment shipment)
		{
			string palletPath = shipment.palletPath;
			UniTask<bool> obj = AssetWarehouse.Instance.LoadPalletFromFolderAsync(palletPath, true, (string)null, shipment.modListing);
			Action action = delegate
			{
				Pallet val = null;
				Enumerator<PalletManifest> enumerator = AssetWarehouse.Instance.GetPalletManifests().GetEnumerator();
				while (enumerator.MoveNext())
				{
					PalletManifest current = enumerator.Current;
					if (current.PalletPath == palletPath)
					{
						val = current.Pallet;
						break;
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					DownloadNotifications.SendDownloadNotification(((Scannable)val).Title);
				}
				DownloadCallbackInfo downloadCallbackInfo = default(DownloadCallbackInfo);
				downloadCallbackInfo.Pallet = val;
				downloadCallbackInfo.Result = ModResult.SUCCEEDED;
				DownloadCallbackInfo info = downloadCallbackInfo;
				shipment.callback?.Invoke(info);
			};
			obj.GetAwaiter().OnCompleted(Action.op_Implicit(action));
		}

		public static void SchedulePalletLoad(PalletShipment shipment)
		{
			if (!_scheduledShipments.Contains(shipment))
			{
				_scheduledShipments.Enqueue(shipment);
			}
		}
	}
	public enum ModResult
	{
		NONE,
		FAILED,
		SUCCEEDED,
		CANCELED
	}
}
namespace LabFusion.Downloading.ModIO
{
	public delegate void ModCallback(ModCallbackInfo info);
	public struct ModCallbackInfo
	{
		public static readonly ModCallbackInfo FailedCallback = new ModCallbackInfo
		{
			Data = default(ModData),
			Result = ModResult.FAILED
		};

		public ModData Data;

		public ModResult Result;
	}
	[Serializable]
	public readonly struct ModData
	{
		public string NameID { get; }

		public int ID { get; }

		public int MaturityOption { get; }

		public IReadOnlyList<ModPlatformData> Platforms { get; }

		public string ThumbnailUrl { get; }

		public bool Mature => MaturityOption > 0;

		public ModData(JToken token)
		{
			NameID = token.Value<string>((object)"name_id");
			ID = token.Value<int>((object)"id");
			MaturityOption = token.Value<int>((object)"maturity_option");
			List<ModPlatformData> list = new List<ModPlatformData>();
			JToken[] array = ((IEnumerable<JToken>)token[(object)"platforms"]).ToArray();
			foreach (JToken token2 in array)
			{
				list.Add(new ModPlatformData(token2));
			}
			Platforms = list;
			ThumbnailUrl = ((object)token[(object)"logo"][(object)"thumb_640x360"]).ToString();
		}
	}
	[Serializable]
	public readonly struct ModPlatformData
	{
		public string Platform { get; }

		public int ModFileLive { get; }

		public ModPlatformData(JToken token)
		{
			Platform = token.Value<string>((object)"platform");
			ModFileLive = token.Value<int>((object)"modfile_live");
		}
	}
	public static class ModIODownloader
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass14_0
		{
			public string zipPath;

			public ModTransaction transaction;
		}

		[CompilerGenerated]
		private sealed class <CoDownloadWithToken>d__14 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ModTransaction transaction;

			public string token;

			public string url;

			private <>c__DisplayClass14_0 <>8__1;

			public ModIOFile modFile;

			private HttpClient <client>5__2;

			private Task<HttpResponseMessage> <responseTask>5__3;

			private long <contentLength>5__4;

			private FileStream <copyStream>5__5;

			private Task <copyTask>5__6;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <CoDownloadWithToken>d__14(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if ((uint)(num - -4) <= 1u || (uint)(num - 1) <= 1u)
				{
					try
					{
						if (num == -4 || num == 2)
						{
							try
							{
							}
							finally
							{
								<>m__Finally2();
							}
						}
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>8__1 = null;
				<client>5__2 = null;
				<responseTask>5__3 = null;
				<copyStream>5__5 = null;
				<copyTask>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
					{
						<>1__state = -1;
						<>8__1 = new <>c__DisplayClass14_0();
						<>8__1.transaction = transaction;
						ModDownloadManager.ValidateDirectories();
						<>8__1.transaction.Report(0f);
						HttpClientHandler handler = new HttpClientHandler
						{
							ClientCertificateOptions = ClientCertificateOption.Manual,
							ServerCertificateCustomValidationCallback = (HttpRequestMessage _, X509Certificate2? _, X509Chain? _, SslPolicyErrors _) => true
						};
						<client>5__2 = new HttpClient(handler);
						<>1__state = -3;
						<client>5__2.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
						<responseTask>5__3 = <client>5__2.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
						goto IL_00ff;
					}
					case 1:
						<>1__state = -3;
						goto IL_00ff;
					case 2:
						{
							<>1__state = -4;
							goto IL_02c8;
						}
						IL_02c8:
						if (<copyTask>5__6.IsCompleted)
						{
							if (!<copyTask>5__6.IsCompletedSuccessfully)
							{
								FusionLogger.LogException("copying downloaded zip", <copyTask>5__6.Exception);
								FailDownload();
								result = false;
								<>m__Finally2();
							}
							else
							{
								<copyTask>5__6 = null;
								<>m__Finally2();
								<copyStream>5__5 = null;
								<>8__1.transaction.Report(1f);
								ModDownloadManager.LoadPalletFromZip(<>8__1.zipPath, modFile, <>8__1.transaction.Temporary, OnScheduledLoad, <>8__1.transaction.Callback);
								result = false;
							}
							break;
						}
						<>8__1.transaction.Report((float)<copyStream>5__5.Length / (float)<contentLength>5__4);
						<>2__current = null;
						<>1__state = 2;
						result = true;
						goto end_IL_0000;
						IL_00ff:
						if (<responseTask>5__3.IsCompleted)
						{
							if (!<responseTask>5__3.IsCompletedSuccessfully)
							{
								FusionLogger.LogException("getting response from mod.io", <responseTask>5__3.Exception);
								FailDownload();
								result = false;
								break;
							}
							HttpContent content = <responseTask>5__3.Result.Content;
							<contentLength>5__4 = content.Headers.ContentLength.Value;
							long? maxBytes = <>8__1.transaction.MaxBytes;
							if (maxBytes.HasValue && <contentLength>5__4 > maxBytes.Value)
							{
								FusionLogger.Warn($"Skipped download of mod {modFile.ModID} due to the file size being too large.");
								FailDownload();
								result = false;
								break;
							}
							<>8__1.zipPath = ModDownloadManager.DownloadPath + $"/m{modFile.ModID}f{modFile.FileID}.zip";
							<copyStream>5__5 = new FileStream(<>8__1.zipPath, FileMode.Create);
							<>1__state = -4;
							<copyTask>5__6 = content.CopyToAsync(<copyStream>5__5);
							goto IL_02c8;
						}
						<>2__current = null;
						<>1__state = 1;
						result = true;
						goto end_IL_0000;
					}
					<>m__Finally1();
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
				void FailDownload()
				{
					((<>c__DisplayClass14_0)this).transaction.Callback?.Invoke(DownloadCallbackInfo.FailedCallback);
					EndDownload();
				}
				void OnScheduledLoad()
				{
					File.Delete(((<>c__DisplayClass14_0)this).zipPath);
					EndDownload();
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<client>5__2 != null)
				{
					((IDisposable)<client>5__2).Dispose();
				}
			}

			private void <>m__Finally2()
			{
				<>1__state = -3;
				if (<copyStream>5__5 != null)
				{
					((IDisposable)<copyStream>5__5).Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static ModTransaction _currentTransaction = null;

		private static bool _isDownloading = false;

		private static readonly Queue<ModTransaction> _queuedTransactions = new Queue<ModTransaction>();

		public static ModTransaction CurrentTransaction => _currentTransaction;

		public static bool IsDownloading => _isDownloading;

		public static Queue<ModTransaction> QueuedTransactions => _queuedTransactions;

		public static void CancelQueue()
		{
			int count = QueuedTransactions.Count;
			for (int i = 0; i < count; i++)
			{
				QueuedTransactions.Dequeue().Callback?.Invoke(DownloadCallbackInfo.CanceledCallback);
			}
		}

		public static void UpdateQueue()
		{
			if (!IsDownloading && QueuedTransactions.Count > 0)
			{
				BeginDownload(QueuedTransactions.Dequeue());
			}
			ModForklift.UpdateForklift();
		}

		public static ModTransaction GetTransaction(int modId)
		{
			if (IsDownloading && CurrentTransaction.ModFile.ModID == modId)
			{
				return CurrentTransaction;
			}
			return QueuedTransactions.FirstOrDefault((ModTransaction transaction) => transaction.ModFile.ModID == modId);
		}

		public static void EnqueueDownload(ModTransaction transaction)
		{
			ModTransaction transaction2 = GetTransaction(transaction.ModFile.ModID);
			if (transaction2 != null)
			{
				transaction2.HookDownload(transaction.Callback);
			}
			else
			{
				QueuedTransactions.Enqueue(transaction);
			}
		}

		private static void BeginDownload(ModTransaction transaction)
		{
			_currentTransaction = transaction;
			_isDownloading = true;
			ModIOFile modFile2 = transaction.ModFile;
			ModIOManager.GetMod(modFile2.ModID, OnRequestedMod);
			void FailDownload()
			{
				transaction.Callback?.Invoke(DownloadCallbackInfo.FailedCallback);
				EndDownload();
			}
			void OnReceivedFile(ModIOFile modFile)
			{
				int modID = modFile.ModID;
				string url;
				if (ModBlacklist.IsBlacklisted(modID.ToString()) || GlobalModBlacklistManager.IsModIDBlacklisted(modFile.ModID))
				{
					FusionLogger.Warn($"Skipped download of mod {modID} due to it being blacklisted!");
					FailDownload();
				}
				else
				{
					url = ModIOSettings.FormatDownloadPath(modFile.ModID, modFile.FileID.Value);
					ModIOSettings.LoadToken(OnTokenLoaded);
				}
				void OnTokenLoaded(string token)
				{
					if (string.IsNullOrWhiteSpace(token))
					{
						FailDownload();
					}
					else
					{
						MelonCoroutines.Start(CoDownloadWithToken(token, transaction, modFile, url));
					}
				}
			}
			void OnRequestedMod(ModCallbackInfo info)
			{
				if (info.Result != ModResult.SUCCEEDED)
				{
					if (modFile2.FileID.HasValue)
					{
						OnReceivedFile(modFile2);
					}
					else
					{
						FusionLogger.Warn($"Failed getting a mod file for mod {modFile2.ModID}, cancelling download!");
						FailDownload();
					}
				}
				else if (info.Data.Mature && !CommonPreferences.ShowMatureMods)
				{
					FusionLogger.Warn("Skipped download of mod " + info.Data.NameID + " due to it containing mature content.");
					FailDownload();
				}
				else if (ModBlacklist.IsBlacklisted(info.Data.NameID) || GlobalModBlacklistManager.IsNameIDBlacklisted(info.Data.NameID))
				{
					FusionLogger.Warn("Skipped download of mod " + info.Data.NameID + " due to it being blacklisted!");
					FailDownload();
				}
				else
				{
					ModPlatformData? validPlatform = ModIOManager.GetValidPlatform(info.Data);
					if (!validPlatform.HasValue)
					{
						FusionLogger.Warn($"Tried beginning download for mod {modFile2.ModID}, but it had no valid platforms!");
						FailDownload();
					}
					else
					{
						modFile2 = new ModIOFile(info.Data.ID, validPlatform.Value.ModFileLive);
						OnReceivedFile(modFile2);
					}
				}
			}
		}

		[IteratorStateMachine(typeof(<CoDownloadWithToken>d__14))]
		private static IEnumerator CoDownloadWithToken(string token, ModTransaction transaction, ModIOFile modFile, string url)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoDownloadWithToken>d__14(0)
			{
				token = token,
				transaction = transaction,
				modFile = modFile,
				url = url
			};
		}

		private static void EndDownload()
		{
			_currentTransaction = null;
			_isDownloading = false;
		}
	}
	public readonly struct ModIOFile
	{
		public int ModID { get; }

		public int? FileID { get; }

		public ModIOFile(int modID, int? fileID = null)
		{
			ModID = modID;
			FileID = fileID;
		}
	}
	public static class ModIOManager
	{
		[CompilerGenerated]
		private sealed class <CoGetMod>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string token;

			public string url;

			public ModCallback modCallback;

			private HttpClient <client>5__2;

			private Task<Stream> <streamTask>5__3;

			private Task<string> <jsonTask>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <CoGetMod>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<client>5__2 = null;
				<streamTask>5__3 = null;
				<jsonTask>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
					{
						<>1__state = -1;
						HttpClientHandler handler = new HttpClientHandler
						{
							ClientCertificateOptions = ClientCertificateOption.Manual,
							ServerCertificateCustomValidationCallback = (HttpRequestMessage _, X509Certificate2? _, X509Chain? _, SslPolicyErrors _) => true
						};
						<client>5__2 = new HttpClient(handler);
						<>1__state = -3;
						<client>5__2.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
						try
						{
							<streamTask>5__3 = <client>5__2.GetStreamAsync(url);
						}
						catch (Exception e)
						{
							FusionLogger.LogException("getting stream from HttpClient", e);
							modCallback?.Invoke(ModCallbackInfo.FailedCallback);
							result = false;
							break;
						}
						goto IL_00f3;
					}
					case 1:
						<>1__state = -3;
						goto IL_00f3;
					case 2:
						{
							<>1__state = -3;
							goto IL_0190;
						}
						IL_0190:
						if (<jsonTask>5__4.IsCompleted)
						{
							if (!<jsonTask>5__4.IsCompletedSuccessfully)
							{
								modCallback?.Invoke(ModCallbackInfo.FailedCallback);
								result = false;
								break;
							}
							JObject val = JObject.Parse(<jsonTask>5__4.Result);
							ModData data = new ModData((JToken)(object)val);
							ModCallbackInfo modCallbackInfo = default(ModCallbackInfo);
							modCallbackInfo.Data = data;
							modCallbackInfo.Result = ModResult.SUCCEEDED;
							ModCallbackInfo info = modCallbackInfo;
							modCallback?.Invoke(info);
							result = false;
							break;
						}
						<>2__current = null;
						<>1__state = 2;
						result = true;
						goto end_IL_0000;
						IL_00f3:
						if (<streamTask>5__3.IsCompleted)
						{
							if (!<streamTask>5__3.IsCompletedSuccessfully)
							{
								modCallback?.Invoke(ModCallbackInfo.FailedCallback);
								result = false;
								break;
							}
							try
							{
								<jsonTask>5__4 = new StreamReader(<streamTask>5__3.Result).ReadToEndAsync();
							}
							catch (Exception e2)
							{
								FusionLogger.LogException("reading mod.io mod stream", e2);
								modCallback?.Invoke(ModCallbackInfo.FailedCallback);
								result = false;
								break;
							}
							goto IL_0190;
						}
						<>2__current = null;
						<>1__state = 1;
						result = true;
						goto end_IL_0000;
					}
					<>m__Finally1();
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<client>5__2 != null)
				{
					((IDisposable)<client>5__2).Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static ModIOModTarget GetTargetFromListing(ModListing listing)
		{
			if (listing == null)
			{
				return null;
			}
			Enumerator<string, ModTarget> enumerator = ((Dictionary<string, ModTarget>)(object)listing.Targets).Values.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ModIOModTarget val = ((Il2CppObjectBase)enumerator.Current).TryCast<ModIOModTarget>();
				if (val != null)
				{
					return val;
				}
			}
			return null;
		}

		public static void GetMod(int modID, ModCallback modCallback)
		{
			string url = $"{ModIOSettings.GameApiPath}{modID}";
			ModIOSettings.LoadToken(OnTokenLoaded);
			void OnTokenLoaded(string token)
			{
				if (string.IsNullOrWhiteSpace(token))
				{
					modCallback?.Invoke(ModCallbackInfo.FailedCallback);
				}
				else
				{
					MelonCoroutines.Start(CoGetMod(url, token, modCallback));
				}
			}
		}

		[IteratorStateMachine(typeof(<CoGetMod>d__2))]
		private static IEnumerator CoGetMod(string url, string token, ModCallback modCallback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoGetMod>d__2(0)
			{
				url = url,
				token = token,
				modCallback = modCallback
			};
		}

		public static string GetActivePlatform()
		{
			if (PlatformHelper.IsAndroid)
			{
				return "android";
			}
			return "windows";
		}

		public static ModPlatformData? GetValidPlatform(ModData mod)
		{
			string activePlatform = GetActivePlatform();
			foreach (ModPlatformData platform in mod.Platforms)
			{
				if (!(platform.Platform != activePlatform))
				{
					return platform;
				}
			}
			return null;
		}
	}
	public static class ModIOSettings
	{
		[CompilerGenerated]
		private sealed class <CoLoadToken>d__17 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private FileStream <stream>5__2;

			private Task<string> <settingsTask>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <CoLoadToken>d__17(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<stream>5__2 = null;
				<settingsTask>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
					{
						<>1__state = -1;
						_isLoadingToken = true;
						string modSettingsPath = ModDownloader.ModSettingsPath;
						if (File.Exists(modSettingsPath))
						{
							<stream>5__2 = new FileStream(modSettingsPath, FileMode.Open);
							<>1__state = -3;
							StreamReader streamReader = new StreamReader(<stream>5__2);
							<settingsTask>5__3 = streamReader.ReadToEndAsync();
							break;
						}
						if (!_loggedMissingToken)
						{
							FusionLogger.Error("mod.io token is missing! Please set it in the mods menu!");
							_loggedMissingToken = true;
						}
						EndLoadToken(null);
						result = false;
						goto end_IL_0000;
					}
					case 1:
						<>1__state = -3;
						break;
					}
					if (!<settingsTask>5__3.IsCompleted)
					{
						<>2__current = null;
						<>1__state = 1;
						result = true;
					}
					else
					{
						if (!<settingsTask>5__3.IsCompletedSuccessfully)
						{
							FusionLogger.Error("Failed reading mod.io token from settings!");
							EndLoadToken(null);
							result = false;
						}
						else
						{
							EndLoadToken(((object)JObject.Parse(<settingsTask>5__3.Result)["mod.io.access_token"]).ToString());
							result = false;
						}
						<>m__Finally1();
					}
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<stream>5__2 != null)
				{
					((IDisposable)<stream>5__2).Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static string _loadedToken = null;

		private static bool _isLoadingToken = false;

		private static bool _loggedMissingToken = false;

		private static Action<string> _tokenLoadCallback = null;

		public static int GameID { get; set; } = 3809;


		public static string GameApiPath => $"https://g-{GameID}.modapi.io/v1/games/{GameID}/mods/";

		public static string LoadedToken => _loadedToken;

		public static bool IsLoadingToken => _isLoadingToken;

		public static string FormatFilePath(int modId, int fileId)
		{
			return $"{GameApiPath}{modId}/files/{fileId}";
		}

		public static string FormatDownloadPath(int modId, int fileId)
		{
			return FormatFilePath(modId, fileId) + "/download";
		}

		public static void LoadToken(Action<string> loadCallback)
		{
			if (!string.IsNullOrWhiteSpace(LoadedToken))
			{
				loadCallback?.Invoke(LoadedToken);
				return;
			}
			_tokenLoadCallback = (Action<string>)Delegate.Combine(_tokenLoadCallback, loadCallback);
			if (!IsLoadingToken)
			{
				MelonCoroutines.Start(CoLoadToken());
			}
		}

		[IteratorStateMachine(typeof(<CoLoadToken>d__17))]
		private static IEnumerator CoLoadToken()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoLoadToken>d__17(0);
		}

		private static void EndLoadToken(string token)
		{
			_loadedToken = token;
			try
			{
				_tokenLoadCallback?.Invoke(token);
				_tokenLoadCallback = null;
			}
			catch (Exception e)
			{
				FusionLogger.LogException("invoking token load callback", e);
			}
			_isLoadingToken = false;
		}
	}
	public static class ModIOThumbnailDownloader
	{
		[CompilerGenerated]
		private sealed class <CoDownloadThumbnail>d__6 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string url;

			public Action<Texture> callback;

			private HttpClient <client>5__2;

			private Task<HttpResponseMessage> <responseTask>5__3;

			private Task<byte[]> <bytesTask>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <CoDownloadThumbnail>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<client>5__2 = null;
				<responseTask>5__3 = null;
				<bytesTask>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
					{
						<>1__state = -1;
						HttpClientHandler handler = new HttpClientHandler
						{
							ClientCertificateOptions = ClientCertificateOption.Automatic,
							ServerCertificateCustomValidationCallback = (HttpRequestMessage _, X509Certificate2? _, X509Chain? _, SslPolicyErrors _) => true
						};
						<client>5__2 = new HttpClient(handler);
						<>1__state = -3;
						<responseTask>5__3 = <client>5__2.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
						goto IL_00a4;
					}
					case 1:
						<>1__state = -3;
						goto IL_00a4;
					case 2:
						{
							<>1__state = -3;
							break;
						}
						IL_00a4:
						if (<responseTask>5__3.IsCompleted)
						{
							HttpContent content = <responseTask>5__3.Result.Content;
							<bytesTask>5__4 = content.ReadAsByteArrayAsync();
							break;
						}
						<>2__current = null;
						<>1__state = 1;
						result = true;
						goto end_IL_0000;
					}
					if (!<bytesTask>5__4.IsCompleted)
					{
						<>2__current = null;
						<>1__state = 2;
						result = true;
					}
					else
					{
						byte[] result2 = <bytesTask>5__4.Result;
						Texture2D val = new Texture2D(1, 1);
						ImageConversion.LoadImage(val, Il2CppStructArray<byte>.op_Implicit(result2));
						callback?.Invoke((Texture)(object)val);
						result = false;
						<>m__Finally1();
					}
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<client>5__2 != null)
				{
					((IDisposable)<client>5__2).Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static Dictionary<int, Texture> ThumbnailCache { get; } = new Dictionary<int, Texture>();


		public static void ClearCache()
		{
			foreach (Texture value in ThumbnailCache.Values)
			{
				if (!((Object)(object)value == (Object)null))
				{
					Object.Destroy((Object)(object)value);
				}
			}
			ThumbnailCache.Clear();
		}

		public static void GetThumbnail(int modID, Action<Texture> callback)
		{
			if (ThumbnailCache.TryGetValue(modID, out var value))
			{
				callback?.Invoke(value);
				return;
			}
			callback = (Action<Texture>)Delegate.Combine(callback, (Action<Texture>)delegate(Texture texture)
			{
				ThumbnailCache[modID] = texture;
			});
			ModIOManager.GetMod(modID, OnModReceived);
			void OnModReceived(ModCallbackInfo info)
			{
				if (info.Result == ModResult.SUCCEEDED && (!info.Data.Mature || CommonPreferences.ShowMatureMods))
				{
					GetThumbnail(info.Data.ThumbnailUrl, callback);
				}
			}
		}

		public static void GetThumbnail(string url, Action<Texture> callback)
		{
			MelonCoroutines.Start(CoDownloadThumbnail(url, callback));
		}

		[IteratorStateMachine(typeof(<CoDownloadThumbnail>d__6))]
		private static IEnumerator CoDownloadThumbnail(string url, Action<Texture> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoDownloadThumbnail>d__6(0)
			{
				url = url,
				callback = callback
			};
		}
	}
	public static class ModReferences
	{
		public const int FusionContentId = 4106243;

		public const int FusionCosmeticsId = 4106245;

		public const string FusionContentURL = "https://mod.io/g/bonelab/m/fusion-content";
	}
	public class ModTransaction : IProgress<float>
	{
		private float _progress;

		public ModIOFile ModFile { get; set; }

		public bool Temporary { get; set; }

		public DownloadCallback Callback { get; set; }

		public long? MaxBytes { get; set; }

		public float Progress => _progress;

		public IProgress<float> Reporter { get; set; }

		public void HookDownload(DownloadCallback callback)
		{
			Callback = (DownloadCallback)Delegate.Combine(Callback, callback);
		}

		public void Report(float value)
		{
			_progress = value;
			try
			{
				Reporter?.Report(value);
			}
			catch (Exception e)
			{
				FusionLogger.LogException("reporting progress of mod transaction", e);
			}
		}
	}
	public class SerializedModIOFile : LabFusion.Network.Serialization.INetSerializable
	{
		public static readonly SerializedModIOFile Default = new SerializedModIOFile(null);

		public ModIOFile File;

		public bool HasFile;

		public string Platform;

		public int? GetSize()
		{
			return 9 + Platform.GetSize();
		}

		public void Serialize(INetSerializer serializer)
		{
			int value = File.ModID;
			int? value2 = File.FileID;
			serializer.SerializeValue(ref value);
			serializer.SerializeValue(ref value2);
			serializer.SerializeValue(ref HasFile);
			serializer.SerializeValue(ref Platform);
			if (serializer.IsReader)
			{
				if (Platform != ModIOManager.GetActivePlatform())
				{
					value2 = null;
				}
				File = new ModIOFile(value, value2);
			}
		}

		public SerializedModIOFile()
		{
		}

		public SerializedModIOFile(ModIOFile? file)
		{
			HasFile = file.HasValue;
			if (HasFile)
			{
				File = file.Value;
			}
			Platform = ModIOManager.GetActivePlatform();
		}
	}
}
namespace LabFusion.Debugging
{
	public static class FusionDevMode
	{
		public const bool UnlockEverything = false;
	}
}
namespace LabFusion.XML
{
	public interface IXMLPackable
	{
		void Pack(XElement element);

		void Unpack(XElement element);
	}
}
namespace LabFusion.Data
{
	public class ComponentHashData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 8;

		public int Hash;

		public int Index;

		public int? GetSize()
		{
			return 8;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Hash);
			serializer.SerializeValue(ref Index);
		}
	}
	public class ComponentHashTable<TComponent> where TComponent : Component
	{
		private readonly Dictionary<int, List<TComponent>> _hashToComponents = new Dictionary<int, List<TComponent>>();

		private readonly Dictionary<TComponent, int> _componentToHash = new Dictionary<TComponent, int>((IEqualityComparer<TComponent>?)new UnityComparer());

		public Dictionary<int, List<TComponent>> HashToComponents => _hashToComponents;

		public Dictionary<TComponent, int> ComponentToHash => _componentToHash;

		public int AddComponent(int hash, TComponent component)
		{
			if (!HashToComponents.TryGetValue(hash, out var value))
			{
				value = new List<TComponent>();
				HashToComponents.Add(hash, value);
			}
			value.Add(component);
			ComponentToHash.Add(component, hash);
			return value.Count - 1;
		}

		public void RemoveComponent(TComponent component)
		{
			if (!ComponentToHash.TryGetValue(component, out var value))
			{
				return;
			}
			ComponentToHash.Remove(component);
			if (HashToComponents.TryGetValue(value, out var value2))
			{
				value2.RemoveAll((TComponent e) => (Object)(object)e == (Object)(object)component);
				if (value2.Count <= 0)
				{
					HashToComponents.Remove(value);
				}
			}
		}

		public TComponent GetComponentFromData(ComponentHashData data)
		{
			if (data == null)
			{
				return default(TComponent);
			}
			if (!HashToComponents.TryGetValue(data.Hash, out var value))
			{
				return default(TComponent);
			}
			if (data.Index >= value.Count || data.Index < 0)
			{
				return default(TComponent);
			}
			return value[data.Index];
		}

		public ComponentHashData GetDataFromComponent(TComponent component)
		{
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			if (!ComponentToHash.TryGetValue(component, out var value))
			{
				return null;
			}
			int index = HashToComponents[value].FindIndex((TComponent e) => (Object)(object)e == (Object)(object)component);
			return new ComponentHashData
			{
				Hash = value,
				Index = index
			};
		}

		public bool IsHashed(TComponent component)
		{
			if ((Object)(object)component != (Object)null)
			{
				return ComponentToHash.ContainsKey(component);
			}
			return false;
		}
	}
	[Serializable]
	public class DataCorruptionException : Exception
	{
		public DataCorruptionException(string message)
			: base(message)
		{
		}

		public DataCorruptionException(string message, Exception inner)
			: base(message, inner)
		{
		}

		protected DataCorruptionException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public static class FusionSpecialDates
	{
		public enum FusionDate
		{
			NONE,
			FUSION_BIRTHDAY,
			BONELAB_BIRTHDAY,
			HALLOWEEN,
			CHRISTMAS
		}

		private enum Month
		{
			JANUARY = 1,
			FEBRUARY,
			MARCH,
			APRIL,
			MAY,
			JUNE,
			JULY,
			AUGUST,
			SEPTEMBER,
			OCTOBER,
			NOVEMBER,
			DECEMBER
		}

		public static FusionDate GetCurrentDate()
		{
			DateTime now = DateTime.Now;
			switch ((Month)now.Month)
			{
			case Month.MARCH:
				if (System.Math.Abs(now.Day - 14) <= 4)
				{
					return FusionDate.FUSION_BIRTHDAY;
				}
				break;
			case Month.SEPTEMBER:
				if (System.Math.Abs(now.Day - 29) <= 4)
				{
					return FusionDate.BONELAB_BIRTHDAY;
				}
				break;
			case Month.OCTOBER:
				if (now.Day <= 31 && now.Day >= 20)
				{
					return FusionDate.HALLOWEEN;
				}
				break;
			case Month.DECEMBER:
				if (now.Day <= 25 && now.Day >= 12)
				{
					return FusionDate.CHRISTMAS;
				}
				break;
			}
			return FusionDate.NONE;
		}
	}
	public struct GripPair
	{
		public readonly Hand hand;

		public readonly Grip grip;

		public GripPair(Hand hand, Grip grip)
		{
			this.hand = hand;
			this.grip = grip;
		}
	}
	public class EntityGrabGroupHandler : GrabGroupHandler<SerializedEntityGrab>
	{
		public override GrabGroup? Group => GrabGroup.ENTITY;
	}
	public class SerializedEntityGrab : SerializedGrab
	{
		public new const int Size = 24;

		public ushort index;

		public ushort id;

		public SerializedEntityGrab()
		{
		}

		public SerializedEntityGrab(ushort index, ushort id)
		{
			this.index = index;
			this.id = id;
		}

		public override void Serialize(INetSerializer serializer)
		{
			base.Serialize(serializer);
			serializer.SerializeValue(ref index);
			serializer.SerializeValue(ref id);
		}

		public Grip GetGrip(out NetworkEntity entity)
		{
			entity = null;
			NetworkEntity entity2 = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(id);
			if (entity2 != null)
			{
				entity = entity2;
				GripExtender extender = entity2.GetExtender<GripExtender>();
				if (extender != null)
				{
					return extender.GetComponent(index);
				}
			}
			return null;
		}

		public override Grip GetGrip()
		{
			NetworkEntity entity;
			return GetGrip(out entity);
		}
	}
	public abstract class SerializedGrab : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 20;

		public bool IsGrabbed;

		public SerializedTransform TargetInBase;

		public GripPair GripPair;

		public void WriteDefaultGrip(Hand hand, Grip grip)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			IsGrabbed = (Object)(object)hand.m_CurrentAttachedGO == (Object)(object)((Component)grip).gameObject;
			SimpleTransform targetInBase = grip.GetTargetInBase(hand);
			TargetInBase = new SerializedTransform(targetInBase.position, targetInBase.rotation);
			GripPair = new GripPair(hand, grip);
		}

		public virtual int GetSize()
		{
			return 20;
		}

		public virtual void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref IsGrabbed);
			NetSerializerExtensions.SerializeValue(serializer, ref TargetInBase);
		}

		public abstract Grip GetGrip();

		public void RequestGrab(NetworkPlayer player, Handedness handedness, Grip grip)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)grip == (Object)null) && IsGrabbed && player.HasRig)
			{
				player.Grabber.Attach(handedness, grip, SimpleTransform.Create(TargetInBase.position, TargetInBase.rotation));
			}
		}
	}
	public class StaticGrabGroupHandler : GrabGroupHandler<SerializedStaticGrab>
	{
		public override GrabGroup? Group => GrabGroup.STATIC;
	}
	public class SerializedStaticGrab : SerializedGrab
	{
		public new const int Size = 28;

		public ComponentHashData gripHash;

		public SerializedStaticGrab()
		{
		}

		public SerializedStaticGrab(ComponentHashData gripHash)
		{
			this.gripHash = gripHash;
		}

		public override int GetSize()
		{
			return 28;
		}

		public override void Serialize(INetSerializer serializer)
		{
			base.Serialize(serializer);
			NetSerializerExtensions.SerializeValue(serializer, ref gripHash);
		}

		public override Grip GetGrip()
		{
			return GripPatches.HashTable.GetComponentFromData(gripHash);
		}
	}
	public class WorldGrabGroupHandler : GrabGroupHandler<SerializedWorldGrab>
	{
		public override GrabGroup? Group => GrabGroup.WORLD;
	}
	public class SerializedWorldGrab : SerializedGrab
	{
		public new const int Size = 21;

		public byte grabberId;

		public SerializedWorldGrab()
		{
		}

		public SerializedWorldGrab(byte grabberId)
		{
			this.grabberId = grabberId;
		}

		public override int GetSize()
		{
			return 21;
		}

		public override void Serialize(INetSerializer serializer)
		{
			base.Serialize(serializer);
			serializer.SerializeValue(ref grabberId);
		}

		public override Grip GetGrip()
		{
			if (NetworkPlayerManager.TryGetPlayer(grabberId, out var player) && player.HasRig)
			{
				return (Grip)(object)player.RigRefs.RigManager.worldGrip;
			}
			return null;
		}
	}
	public struct ManagedTransform
	{
		public Vector3 Position;

		public Quaternion Rotation;

		public ManagedTransform(Vector3 position, Quaternion rotation)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			Position = position;
			Rotation = rotation;
		}
	}
	public class PDController
	{
		private const float MaxForce = 5000f;

		private const float MaxTorque = 1000f;

		private const float PositionFrequency = 10f;

		private const float PositionDamping = 3f;

		private const float RotationFrequency = 100f;

		private const float RotationDamping = 10f;

		private static float _positionKp;

		private static float _positionKd;

		private static float _rotationKp;

		private static float _rotationKd;

		private static float _positionKsg;

		private static float _positionKdg;

		private static float _rotationKsg;

		private static float _rotationKdg;

		private static float _lastFixedDelta = 1f;

		private bool _validPosition;

		private bool _validRotation;

		private Vector3 _lastVelocity = Vector3Extensions.zero;

		private Vector3 _lastAngularVelocity = Vector3Extensions.zero;

		private Vector3 _lastPosition = Vector3Extensions.zero;

		private Quaternion _lastRotation = QuaternionExtensions.identity;

		public Vector3 SavedForce { get; set; }

		public Vector3 SavedTorque { get; set; }

		public bool ValidPosition => _validPosition;

		public bool ValidRotation => _validRotation;

		public static void OnInitializeMelon()
		{
			_positionKp = CalculateKP(10f);
			_positionKd = CalculateKD(10f, 3f);
			_rotationKp = CalculateKP(100f);
			_rotationKd = CalculateKD(100f, 10f);
		}

		public static void OnFixedUpdate()
		{
			float fixedDeltaTime = TimeReferences.FixedDeltaTime;
			if (!ManagedMathf.Approximately(fixedDeltaTime, _lastFixedDelta))
			{
				_lastFixedDelta = fixedDeltaTime;
				float num = 1f / (1f + _positionKd * fixedDeltaTime + _positionKp * fixedDeltaTime * fixedDeltaTime);
				_positionKsg = _positionKp * num;
				_positionKdg = (_positionKd + _positionKp * fixedDeltaTime) * num;
				float num2 = 1f / (1f + _rotationKd * fixedDeltaTime + _rotationKp * fixedDeltaTime * fixedDeltaTime);
				_rotationKsg = _rotationKp * num2;
				_rotationKdg = (_rotationKd + _rotationKp * fixedDeltaTime) * num2;
			}
		}

		private static float CalculateKP(float frequency)
		{
			return 6f * frequency * (6f * frequency) * 0.25f;
		}

		private static float CalculateKD(float frequency, float damping)
		{
			return 4.5f * frequency * damping;
		}

		public void ResetPosition()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			_validPosition = false;
			SavedForce = Vector3.zero;
		}

		public void ResetRotation()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			_validRotation = false;
			SavedTorque = Vector3.zero;
		}

		public void Reset()
		{
			ResetPosition();
			ResetRotation();
		}

		public Vector3 GetForce(in Vector3 position, in Vector3 velocity, in Vector3 targetPos, in Vector3 targetVel)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkTransformManager.IsInBounds(targetPos))
			{
				return Vector3.zero;
			}
			Vector3 val = NetworkTransformManager.LimitVelocity(targetVel);
			if (!_validPosition)
			{
				_lastPosition = targetPos;
				_lastVelocity = val;
				_validPosition = true;
			}
			Vector3 val2 = position;
			Vector3 val3 = velocity;
			Vector3 lastPosition = _lastPosition;
			Vector3 lastVelocity = _lastVelocity;
			Vector3 val4 = (lastPosition - val2) * _positionKsg + (lastVelocity - val3) * _positionKdg + (val - _lastVelocity) / _lastFixedDelta;
			_lastVelocity = val;
			_lastPosition = targetPos;
			return Vector3.ClampMagnitude(val4, 5000f);
		}

		public Vector3 GetTorque(in Quaternion rotation, in Vector3 angularVelocity, in Quaternion targetRot, in Vector3 targetVel)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (!_validRotation)
			{
				_lastRotation = targetRot;
				_lastAngularVelocity = targetVel;
				_validRotation = true;
			}
			Quaternion lastRotation = _lastRotation;
			Vector3 lastAngularVelocity = _lastAngularVelocity;
			Quaternion val = lastRotation * Quaternion.Inverse(rotation);
			if (val.w < 0f)
			{
				val.x = 0f - val.x;
				val.y = 0f - val.y;
				val.z = 0f - val.z;
				val.w = 0f - val.w;
			}
			float num = default(float);
			Vector3 val2 = default(Vector3);
			((Quaternion)(ref val)).ToAngleAxis(ref num, ref val2);
			val2 = Vector3.Normalize(val2);
			val2 *= (float)System.Math.PI / 180f;
			Vector3 val3 = _rotationKsg * val2 * num + _rotationKdg * (lastAngularVelocity - angularVelocity) + (targetVel - _lastAngularVelocity) / _lastFixedDelta;
			_lastAngularVelocity = targetVel;
			_lastRotation = targetRot;
			return Vector3.ClampMagnitude(val3, 1000f);
		}
	}
	public static class RigData
	{
		public static RigRefs Refs { get; private set; } = new RigRefs();


		public static bool HasPlayer => Refs.IsValid;

		public static string RigAvatarId { get; internal set; } = MarrowBarcodes.EmptyBarcode;


		public static SerializedAvatarStats RigAvatarStats { get; internal set; } = null;


		public static Vector3 RigSpawn { get; private set; }

		public static Quaternion RigSpawnRot { get; private set; }

		private static void OnJump()
		{
			if (NetworkInfo.HasServer)
			{
				PlayerSender.SendPlayerAction(PlayerActionType.JUMP);
			}
		}

		public static void OnCacheRigInfo()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			PlayerRefs instance = PlayerRefs.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				FusionLogger.Error("PlayerRefs does not exist, cannot get the player's RigManager!");
				return;
			}
			RigManager playerRigManager = instance.PlayerRigManager;
			if ((Object)(object)playerRigManager == (Object)null)
			{
				FusionLogger.Error("Failed to get the player's RigManager!");
				return;
			}
			RigSpawn = ((Component)playerRigManager).transform.position;
			RigSpawnRot = ((Component)playerRigManager).transform.rotation;
			Refs = new RigRefs(playerRigManager);
			RemapRig remapHeptaRig = Refs.RigManager.remapHeptaRig;
			remapHeptaRig.onPlayerJump += Action.op_Implicit((Action)OnJump);
			LocalPlayer.OnLocalRigCreated?.InvokeSafe<Action<RigManager>, RigManager>(playerRigManager, "executing OnLocalRigCreated hook");
			if ((Object)(object)playerRigManager._avatar != (Object)null)
			{
				LocalAvatar.InvokeAvatarChanged(playerRigManager._avatar, ((ScannableReference)playerRigManager.AvatarCrate).Barcode.ID);
			}
		}

		public static string GetAvatarBarcode()
		{
			RigManager rigManager = Refs.RigManager;
			if (Object.op_Implicit((Object)(object)rigManager))
			{
				return ((ScannableReference)rigManager.AvatarCrate).Barcode.ID;
			}
			return MarrowBarcodes.EmptyBarcode;
		}
	}
	public class WeakAssetReference<T> where T : Object
	{
		private T _asset;

		private bool _hasAsset;

		private Action<T> _onLoaded;

		public bool HasAsset => _hasAsset;

		public T Asset => _asset;

		public void Load(Action<T> onLoaded)
		{
			if (_hasAsset)
			{
				onLoaded(_asset);
			}
			else
			{
				_onLoaded = (Action<T>)Delegate.Combine(_onLoaded, onLoaded);
			}
		}

		public void SetAsset(T asset)
		{
			if (!_hasAsset)
			{
				_asset = asset;
				_hasAsset = true;
				_onLoaded?.Invoke(asset);
			}
		}

		public void UnloadAsset()
		{
			if (_hasAsset)
			{
				_asset = default(T);
				_hasAsset = false;
			}
		}

		public static implicit operator T(WeakAssetReference<T> reference)
		{
			return reference.Asset;
		}
	}
	public static class DataConversions
	{
		public const long MEGABYTES_TO_BYTES = 1000000L;

		public static long ConvertMegabytesToBytes(long megabytes)
		{
			return megabytes * 1000000;
		}
	}
	[Serializable]
	public class BanInfo
	{
		[JsonPropertyName("player")]
		public PlayerInfo Player { get; set; }

		[JsonPropertyName("reason")]
		public string Reason { get; set; }
	}
	[Serializable]
	public class BanList
	{
		[JsonPropertyName("bans")]
		public List<BanInfo> Bans { get; set; } = new List<BanInfo>();

	}
	public static class BanManager
	{
		public const string FileName = "bans.json";

		public static BanList BanList { get; private set; } = new BanList();


		public static void ReadFile()
		{
			BanList = new BanList();
			BanList banList = DataSaver.ReadJsonFromFile<BanList>("bans.json");
			if (banList != null)
			{
				BanList = banList;
			}
		}

		private static void WriteFile()
		{
			DataSaver.WriteJsonToFile("bans.json", BanList);
		}

		public static void Ban(PlayerInfo playerInfo, string reason)
		{
			BanInfo item = new BanInfo
			{
				Player = playerInfo,
				Reason = reason
			};
			BanList.Bans.RemoveAll((BanInfo info) => info.Player.PlatformID == playerInfo.PlatformID);
			BanList.Bans.Add(item);
			WriteFile();
		}

		public static void Pardon(ulong longId)
		{
			BanList.Bans.RemoveAll((BanInfo info) => info.Player.PlatformID == longId);
			WriteFile();
		}
	}
	public static class ChangelogLoader
	{
		public static void ReadFile()
		{
			FusionMod.Changelog = ReadFromPath("LabFusion.dependencies.resources.text.raw_changelog.txt", PersistentData.GetPath("raw_changelog.txt"));
			FusionMod.Credits = new string[3]
			{
				ReadFromPath("LabFusion.dependencies.resources.text.credits.raw_credits_01.txt", PersistentData.GetPath("raw_credits_01.txt")),
				ReadFromPath("LabFusion.dependencies.resources.text.credits.raw_credits_02.txt", PersistentData.GetPath("raw_credits_02.txt")),
				ReadFromPath("LabFusion.dependencies.resources.text.credits.raw_credits_03.txt", PersistentData.GetPath("raw_credits_03.txt"))
			};
		}

		private static string ReadFromPath(string resourcePath, string filePath)
		{
			File.WriteAllBytes(filePath, EmbeddedResource.LoadBytesFromAssembly(FusionMod.FusionAssembly, resourcePath));
			string[] array = File.ReadAllLines(filePath);
			StringBuilder stringBuilder = new StringBuilder();
			string[] array2 = array;
			foreach (string value in array2)
			{
				stringBuilder.Append(value);
				stringBuilder.AppendLine();
			}
			return stringBuilder.ToString();
		}
	}
	public static class DataSaver
	{
		public static readonly JsonSerializerOptions SerializerOptions = new JsonSerializerOptions
		{
			IncludeFields = true,
			WriteIndented = true
		};

		public static void WriteJsonToFile<T>(string path, T value)
		{
			string path2 = PersistentData.GetPath(path);
			string directoryName = Path.GetDirectoryName(path2);
			if (!Directory.Exists(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			string contents = JsonSerializer.Serialize(value, SerializerOptions);
			File.WriteAllText(path2, contents);
		}

		public static T ReadJsonFromFile<T>(string path)
		{
			string path2 = PersistentData.GetPath(path);
			if (!File.Exists(path2))
			{
				return default(T);
			}
			string json;
			try
			{
				json = File.ReadAllText(path2);
			}
			catch (UnauthorizedAccessException e)
			{
				FusionLogger.LogException("reading save data at " + path, e);
				return default(T);
			}
			try
			{
				return JsonSerializer.Deserialize<T>(json, SerializerOptions);
			}
			catch (Exception e2)
			{
				FusionLogger.LogException("deserializing save data at " + path, e2);
				File.Delete(path2);
				return default(T);
			}
		}

		public static T ReadJsonFromText<T>(string text)
		{
			try
			{
				return JsonSerializer.Deserialize<T>(text, SerializerOptions);
			}
			catch (Exception e)
			{
				FusionLogger.LogException("deserializing json from text", e);
				return default(T);
			}
		}
	}
	public static class EmbeddedResource
	{
		public static byte[] LoadBytesFromAssembly(Assembly assembly, string name)
		{
			if (!assembly.GetManifestResourceNames().Contains(name))
			{
				return null;
			}
			FusionLogger.Log("Loading embedded resource data " + name + "...", ConsoleColor.DarkCyan);
			using Stream stream = assembly.GetManifestResourceStream(name);
			using MemoryStream memoryStream = new MemoryStream();
			stream.CopyTo(memoryStream);
			FusionLogger.Log("Done!", ConsoleColor.DarkCyan);
			return memoryStream.ToArray();
		}

		public static Assembly LoadAssemblyFromAssembly(Assembly assembly, string name)
		{
			byte[] array = LoadBytesFromAssembly(assembly, name);
			if (array == null)
			{
				return null;
			}
			return Assembly.Load(array);
		}
	}
	public static class FusionFileLoader
	{
		public static void OnInitializeMelon()
		{
			PermissionList.ReadFile();
			BanManager.ReadFile();
			ContactsList.ReadFile();
			PointSaveManager.ReadFile();
			AchievementSaveManager.OnInitializeMelon();
			AchievementSaveManager.ReadFile();
			ChangelogLoader.ReadFile();
			ModBlacklist.OnInitializeMelon();
			ModBlacklist.ReadFile();
		}

		public static void OnDeinitializeMelon()
		{
			PointSaveManager.WriteBackup();
			AchievementSaveManager.WriteBackup();
		}
	}
	public static class ModBlacklist
	{
		private static readonly List<string> _blacklistedModIds = new List<string>();

		public static void OnInitializeMelon()
		{
			CreateFile();
		}

		public static void ReadFile()
		{
			_blacklistedModIds.Clear();
			string[] array = File.ReadAllLines(GetFilePath());
			foreach (string text in array)
			{
				if (!text.StartsWith("#") && !string.IsNullOrWhiteSpace(text))
				{
					_blacklistedModIds.Add(text.Trim());
				}
			}
		}

		public static void CreateFile()
		{
			string filePath = GetFilePath();
			if (!File.Exists(filePath))
			{
				using (StreamWriter streamWriter = File.CreateText(filePath))
				{
					streamWriter.WriteLine("# This file is for preventing the use of specific mods while in a server.");
					streamWriter.WriteLine("# To blacklist a mod, add a mod identifier on its own line.");
					streamWriter.WriteLine("# A mod identifier can either be its mod.io number ID, mod.io URL ID, or AssetWarehouse barcode.");
					streamWriter.WriteLine("# When the identifier is a number ID or URL ID, it will block the mod from being downloaded.");
					streamWriter.WriteLine("# On the other hand, if the identifier is a AssetWarehouse barcode, it will prevent the mod from being used.");
					streamWriter.WriteLine("# For server hosts, blacklisting a barcode prevents all clients from using that mod.");
					streamWriter.WriteLine("#");
					streamWriter.WriteLine("# Examples");
					streamWriter.WriteLine("# -------------------------------------");
					streamWriter.WriteLine("# Number ID");
					streamWriter.WriteLine("# 4057308");
					streamWriter.WriteLine("#");
					streamWriter.WriteLine("# URL ID");
					streamWriter.WriteLine("# test-chambers");
					streamWriter.WriteLine("#");
					streamWriter.WriteLine("# Barcode");
					streamWriter.WriteLine("# SLZ.TestChambers.Level.TestChamber02");
					streamWriter.WriteLine("# SLZ.TestChambers.Level.TestChamber07");
					streamWriter.WriteLine("# -------------------------------------");
				}
			}
		}

		public static string GetFilePath()
		{
			return PersistentData.GetPath("mod_blacklist.txt");
		}

		public static bool IsBlacklisted(string identifier)
		{
			foreach (string blacklistedModId in _blacklistedModIds)
			{
				if (blacklistedModId == identifier)
				{
					return true;
				}
			}
			return false;
		}
	}
	public static class PersistentData
	{
		private static bool _initialized;

		public static string PersistentPath { get; private set; }

		public static void OnPathInitialize()
		{
			if (!_initialized)
			{
				PersistentPath = Application.persistentDataPath + "/Fusion/";
				FusionLogger.Log("Data is at " + PersistentPath + ".", ConsoleColor.DarkCyan);
				ValidateDirectory(PersistentPath);
				_initialized = true;
			}
		}

		public static void ValidateDirectory(string path)
		{
			if (!Directory.Exists(path))
			{
				Directory.CreateDirectory(path);
			}
		}

		public static string GetPath(string appended)
		{
			if (!_initialized)
			{
				OnPathInitialize();
			}
			return PersistentPath + appended;
		}
	}
	public static class ResourcePaths
	{
		public const string SteamAPIPath = "LabFusion.dependencies.resources.lib.x86_64.steam_api64.dll";

		public const string RawChangelogPath = "LabFusion.dependencies.resources.text.raw_changelog.txt";

		public const string RawCreditsPath = "LabFusion.dependencies.resources.text.credits.raw_credits_0";

		public const string AppDataSubFolder = "/Fusion/";
	}
	public static class SteamAPILoader
	{
		private static IntPtr _libraryPtr;

		public static bool HasSteamAPI { get; private set; }

		public static void OnLoadSteamAPI()
		{
			if (HasSteamAPI)
			{
				return;
			}
			if (PlatformHelper.IsAndroid)
			{
				HasSteamAPI = false;
				return;
			}
			string path = PersistentData.GetPath("steam_api64.dll");
			ExtractAPI(path);
			if (TryLoadAPI(path, out var libraryPtr, out var errorCode))
			{
				OnLoadAPI(libraryPtr);
			}
			else if (errorCode == 193)
			{
				FusionLogger.Error("steam_api64.dll was corrupted, attempting re-extraction...");
				ExtractAPI(path, overwrite: true);
				if (TryLoadAPI(path, out libraryPtr, out var _))
				{
					OnLoadAPI(libraryPtr);
				}
			}
		}

		public static void OnFreeSteamAPI()
		{
			if (HasSteamAPI)
			{
				DllTools.FreeLibrary(_libraryPtr);
				HasSteamAPI = false;
			}
		}

		private static void ExtractAPI(string path, bool overwrite = false)
		{
			if (!File.Exists(path) || overwrite)
			{
				File.WriteAllBytes(path, EmbeddedResource.LoadBytesFromAssembly(FusionMod.FusionAssembly, "LabFusion.dependencies.resources.lib.x86_64.steam_api64.dll"));
			}
			else
			{
				FusionLogger.Log("steam_api64.dll already exists, skipping extraction.");
			}
		}

		private static bool TryLoadAPI(string path, out IntPtr libraryPtr, out uint errorCode)
		{
			errorCode = 0u;
			libraryPtr = DllTools.LoadLibrary(path);
			if (libraryPtr != IntPtr.Zero)
			{
				return true;
			}
			errorCode = DllTools.GetLastError();
			return false;
		}

		private static void OnLoadAPI(IntPtr libraryPtr)
		{
			_libraryPtr = libraryPtr;
			FusionLogger.Log("Successfully loaded steam_api64.dll into the application!");
			HasSteamAPI = true;
		}
	}
	public sealed class Contact
	{
		public ulong id;

		public string username;

		public float volume;

		public XElement CreateElement()
		{
			XElement xElement = new XElement("Contact");
			xElement.SetAttributeValue("id", id);
			xElement.SetAttributeValue("username", username);
			xElement.SetAttributeValue("volume", volume);
			return xElement;
		}

		public Contact(PlayerID id)
		{
			Update(id);
			volume = 1f;
		}

		public void Update(PlayerID id)
		{
			this.id = id;
			username = id.Metadata.Username.GetValueOrEmpty();
		}

		public Contact(XElement element)
		{
			id = 0uL;
			username = string.Empty;
			volume = 1f;
			if (element.TryGetAttribute("id", out var value))
			{
				ulong.TryParse(value, out id);
			}
			if (element.TryGetAttribute("username", out var value2))
			{
				username = value2;
			}
			if (element.TryGetAttribute("volume", out var value3))
			{
				float.TryParse(value3, out volume);
			}
		}
	}
	public static class ContactsList
	{
		private const string _rootName = "Contacts";

		private const string _fileName = "contacts.xml";

		private static readonly List<Contact> _contacts = new List<Contact>();

		private static XMLFile _file;

		public static IReadOnlyList<Contact> Contacts => _contacts;

		public static event Action<Contact> OnContactUpdated;

		public static void ReadFile()
		{
			_contacts.Clear();
			_file = new XMLFile("contacts.xml", "Contacts");
			_file.ReadFile(delegate(XDocument d)
			{
				d.Descendants("Contact").ForEach(delegate(XElement element)
				{
					_contacts.Add(new Contact(element));
				});
			});
		}

		private static void WriteFile()
		{
			List<object> list = new List<object>();
			foreach (Contact contact in Contacts)
			{
				list.Add(contact.CreateElement());
			}
			_file.WriteFile(list);
		}

		public static Contact GetContact(PlayerID id)
		{
			for (int i = 0; i < Contacts.Count; i++)
			{
				Contact contact = Contacts[i];
				if (contact.id == (ulong)id)
				{
					contact.Update(id);
					return contact;
				}
			}
			return new Contact(id);
		}

		public static void UpdateContact(Contact contact)
		{
			bool flag = false;
			for (int i = 0; i < Contacts.Count; i++)
			{
				if (Contacts[i].id == contact.id)
				{
					_contacts[i] = contact;
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				_contacts.Add(contact);
			}
			ContactsList.OnContactUpdated?.Invoke(contact);
			WriteFile();
		}
	}
	public static class PermissionList
	{
		private const string _rootName = "PermissionList";

		private const string _fileName = "permissionList.xml";

		private const string _elementName = "Permission";

		private const string _idName = "id";

		private const string _userName = "username";

		private const string _levelName = "level";

		private static readonly List<Tuple<ulong, string, PermissionLevel>> _permittedUsers = new List<Tuple<ulong, string, PermissionLevel>>();

		private static XMLFile _file;

		public static IReadOnlyList<Tuple<ulong, string, PermissionLevel>> PermittedUsers => _permittedUsers;

		public static void ReadFile()
		{
			_permittedUsers.Clear();
			_file = new XMLFile("permissionList.xml", "PermissionList");
			_file.ReadFile(delegate(XDocument d)
			{
				d.Descendants("Permission").ForEach(delegate(XElement element)
				{
					if (element.TryGetAttribute("id", out var value) && element.TryGetAttribute("username", out var value2) && element.TryGetAttribute("level", out var value3) && ulong.TryParse(value, out var result) && Enum.TryParse<PermissionLevel>(value3, out var result2))
					{
						_permittedUsers.Add(new Tuple<ulong, string, PermissionLevel>(result, value2, result2));
					}
				});
			});
		}

		private static void WriteFile()
		{
			List<object> list = new List<object>();
			foreach (Tuple<ulong, string, PermissionLevel> permittedUser in _permittedUsers)
			{
				XElement xElement = new XElement("Permission");
				xElement.SetAttributeValue("id", permittedUser.Item1);
				xElement.SetAttributeValue("username", permittedUser.Item2);
				xElement.SetAttributeValue("level", permittedUser.Item3);
				list.Add(xElement);
			}
			_file.WriteFile(list);
		}

		public static void SetPermission(ulong longId, string username, PermissionLevel level)
		{
			Tuple<ulong, string, PermissionLevel> item = new Tuple<ulong, string, PermissionLevel>(longId, username, level);
			Tuple<ulong, string, PermissionLevel>[] array = _permittedUsers.ToArray();
			foreach (Tuple<ulong, string, PermissionLevel> tuple in array)
			{
				if (tuple.Item1 == longId)
				{
					_permittedUsers.Remove(tuple);
					break;
				}
			}
			_permittedUsers.Add(item);
			WriteFile();
		}
	}
	public sealed class XMLFile
	{
		private readonly string _fileName;

		private readonly string _rootName;

		private readonly string _filePath;

		public XMLFile(string fileName, string rootName)
		{
			_fileName = fileName;
			_rootName = rootName;
			_filePath = PersistentData.GetPath(_fileName);
		}

		public void ReadFile(Action<XDocument> onRead)
		{
			XDocument xDocument = null;
			try
			{
				if (File.Exists(_filePath))
				{
					FusionLogger.Log(_rootName + " was found, attempting to read it!", ConsoleColor.DarkCyan);
					xDocument = XDocument.Parse(File.ReadAllText(_filePath));
					if (xDocument.Root.Name != _rootName)
					{
						throw new ArgumentException("Xml root wasn't " + _rootName + ", recreating the xml...");
					}
				}
			}
			catch (Exception e)
			{
				FusionLogger.LogException("parsing " + _rootName, e);
				xDocument = InstantiateDefault("malformed");
			}
			if (xDocument == null)
			{
				xDocument = InstantiateDefault();
			}
			onRead(xDocument);
			XDocument InstantiateDefault(string verb = "missing")
			{
				FusionLogger.Log(_rootName + " was " + verb + ", created it!", ConsoleColor.DarkCyan);
				XDocument xDocument2 = CreateDefault();
				File.WriteAllText(_filePath, xDocument2.ToString());
				return xDocument2;
			}
		}

		public void WriteFile(IList<object> entries)
		{
			XDocument xDocument = CreateDefault();
			for (int i = 0; i < entries.Count; i++)
			{
				xDocument.Root.Add(entries[i]);
			}
			File.WriteAllText(_filePath, xDocument.ToString());
		}

		private XDocument CreateDefault()
		{
			XDocument xDocument = new XDocument();
			xDocument.Add(new XElement(_rootName));
			return xDocument;
		}
	}
	[Serializable]
	public struct JsonVector3
	{
		[JsonPropertyName("x")]
		public float X { get; set; }

		[JsonPropertyName("y")]
		public float Y { get; set; }

		[JsonPropertyName("z")]
		public float Z { get; set; }

		public JsonVector3()
			: this(0f, 0f, 0f)
		{
		}

		public JsonVector3(float x, float y, float z)
		{
			X = x;
			Y = y;
			Z = z;
		}

		public JsonVector3(Vector3 vector3)
			: this(vector3.x, vector3.y, vector3.z)
		{
		}//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)


		public readonly Vector3 ToUnityVector3()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(X, Y, Z);
		}
	}
	[Serializable]
	public class GameInfo : IEquatable<GameInfo>
	{
		[JsonPropertyName("game")]
		public string Game { get; set; }

		public bool Equals(GameInfo other)
		{
			if ((object)other != null)
			{
				return Game == other.Game;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			return Equals(obj as GameInfo);
		}

		public override int GetHashCode()
		{
			return Game.GetHashCode();
		}

		public static bool operator ==(GameInfo x, GameInfo y)
		{
			return x?.Equals(y) ?? ((object)y == null);
		}

		public static bool operator !=(GameInfo x, GameInfo y)
		{
			if ((object)x == null)
			{
				return (object)y != null;
			}
			return !x.Equals(y);
		}
	}
	[Serializable]
	public class LobbyInfo
	{
		public static readonly LobbyInfo Empty = new LobbyInfo();

		[JsonPropertyName("lobbyID")]
		public ulong LobbyID { get; set; }

		[JsonPropertyName("lobbyCode")]
		public string LobbyCode { get; set; }

		[JsonPropertyName("lobbyName")]
		public string LobbyName { get; set; }

		[JsonPropertyName("lobbyDescription")]
		public string LobbyDescription { get; set; }

		[JsonPropertyName("lobbyVersion")]
		public Version LobbyVersion { get; set; } = new Version();


		[JsonPropertyName("lobbyHostName")]
		public string LobbyHostName { get; set; }

		[JsonPropertyName("playerCount")]
		public int PlayerCount { get; set; }

		[JsonPropertyName("playerList")]
		public PlayerList PlayerList { get; set; } = new PlayerList();


		[JsonPropertyName("levelTitle")]
		public string LevelTitle { get; set; }

		[JsonPropertyName("levelBarcode")]
		public string LevelBarcode { get; set; }

		[JsonPropertyName("levelModID")]
		public int LevelModID { get; set; } = -1;


		[JsonPropertyName("gamemodeTitle")]
		public string GamemodeTitle { get; set; }

		[JsonPropertyName("gamemodeBarcode")]
		public string GamemodeBarcode { get; set; }

		[JsonPropertyName("timeBetweenGamemodeRounds")]
		public int TimeBetweenGamemodeRounds { get; set; } = 30;


		[JsonPropertyName("nameTags")]
		public bool NameTags { get; set; }

		[JsonPropertyName("privacy")]
		public ServerPrivacy Privacy { get; set; }

		[JsonPropertyName("slowMoMode")]
		public TimeScaleMode SlowMoMode { get; set; }

		[JsonPropertyName("maxPlayers")]
		public int MaxPlayers { get; set; }

		[JsonPropertyName("voiceChat")]
		public bool VoiceChat { get; set; }

		[JsonPropertyName("playerConstraining")]
		public bool PlayerConstraining { get; set; }

		[JsonPropertyName("mortality")]
		public bool Mortality { get; set; }

		[JsonPropertyName("friendlyFire")]
		public bool FriendlyFire { get; set; }

		[JsonPropertyName("knockout")]
		public bool Knockout { get; set; }

		[JsonPropertyName("knockoutLength")]
		public int KnockoutLength { get; set; }

		[JsonPropertyName("maxAvatarHeight")]
		public float MaxAvatarHeight { get; set; }

		[JsonPropertyName("devTools")]
		public PermissionLevel DevTools { get; set; }

		[JsonPropertyName("constrainer")]
		public PermissionLevel Constrainer { get; set; }

		[JsonPropertyName("customAvatars")]
		public PermissionLevel CustomAvatars { get; set; }

		[JsonPropertyName("kicking")]
		public PermissionLevel Kicking { get; set; }

		[JsonPropertyName("banning")]
		public PermissionLevel Banning { get; set; }

		[JsonPropertyName("teleportation")]
		public PermissionLevel Teleportation { get; set; }

		public void WriteLobby()
		{
			LobbyID = PlayerIDManager.LocalPlatformID;
			LobbyCode = NetworkHelper.GetServerCode();
			LobbyName = SavedServerSettings.ServerName.Value;
			LobbyDescription = SavedServerSettings.ServerDescription.Value;
			LobbyVersion = FusionMod.Version;
			LobbyHostName = LocalPlayer.Username;
			PlayerCount = PlayerIDManager.PlayerCount;
			PlayerList playerList = new PlayerList();
			playerList.WritePlayers();
			PlayerList = playerList;
			LevelTitle = FusionSceneManager.Title;
			LevelBarcode = FusionSceneManager.Barcode;
			LevelModID = CrateFilterer.GetModID(((Crate)FusionSceneManager.Level).Pallet);
			GamemodeTitle = string.Empty;
			GamemodeBarcode = string.Empty;
			if (GamemodeManager.ActiveGamemode != null)
			{
				GamemodeTitle = GamemodeManager.ActiveGamemode.Title;
				GamemodeBarcode = GamemodeManager.ActiveGamemode.Barcode;
			}
			TimeBetweenGamemodeRounds = GamemodeRoundManager.Settings.TimeBetweenRounds;
			NameTags = SavedServerSettings.NameTags.Value;
			Privacy = SavedServerSettings.Privacy.Value;
			SlowMoMode = SavedServerSettings.SlowMoMode.Value;
			MaxPlayers = SavedServerSettings.MaxPlayers.Value;
			VoiceChat = SavedServerSettings.VoiceChat.Value;
			PlayerConstraining = SavedServerSettings.PlayerConstraining.Value;
			Mortality = SavedServerSettings.Mortality.Value;
			FriendlyFire = SavedServerSettings.FriendlyFire.Value;
			Knockout = SavedServerSettings.Knockout.Value;
			KnockoutLength = SavedServerSettings.KnockoutLength.Value;
			MaxAvatarHeight = SavedServerSettings.MaxAvatarHeight.Value;
			DevTools = SavedServerSettings.DevTools.Value;
			Constrainer = SavedServerSettings.Constrainer.Value;
			CustomAvatars = SavedServerSettings.CustomAvatars.Value;
			Kicking = SavedServerSettings.Kicking.Value;
			Banning = SavedServerSettings.Banning.Value;
			Teleportation = SavedServerSettings.Teleportation.Value;
		}
	}
	[Serializable]
	public class PlatformInfo : IEquatable<PlatformInfo>
	{
		[JsonPropertyName("platformID")]
		public ulong PlatformID { get; set; }

		[JsonPropertyName("platform")]
		public string Platform { get; set; }

		public PlatformInfo(ulong platformID)
		{
			PlatformID = platformID;
			if (NetworkLayerManager.HasLayer)
			{
				Platform = NetworkLayerManager.Layer.Platform;
			}
		}

		public bool Equals(PlatformInfo other)
		{
			if ((object)other != null && PlatformID == other.PlatformID)
			{
				return Platform == other.Platform;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			return Equals(obj as PlatformInfo);
		}

		public override int GetHashCode()
		{
			return PlatformID.GetHashCode() ^ Platform.GetHashCode();
		}

		public static bool operator ==(PlatformInfo x, PlatformInfo y)
		{
			return x?.Equals(y) ?? ((object)y == null);
		}

		public static bool operator !=(PlatformInfo x, PlatformInfo y)
		{
			if ((object)x == null)
			{
				return (object)y != null;
			}
			return !x.Equals(y);
		}
	}
	[Serializable]
	public class PlayerInfo
	{
		[JsonPropertyName("platformID")]
		public ulong PlatformID { get; set; }

		[JsonPropertyName("username")]
		public string Username { get; set; }

		[JsonPropertyName("nickname")]
		public string Nickname { get; set; }

		[JsonPropertyName("description")]
		public string Description { get; set; }

		[JsonPropertyName("permissionLevel")]
		public PermissionLevel PermissionLevel { get; set; }

		[JsonPropertyName("avatarTitle")]
		public string AvatarTitle { get; set; }

		[JsonPropertyName("avatarModID")]
		public int AvatarModID { get; set; } = -1;


		public PlayerInfo()
		{
		}

		public PlayerInfo(PlayerID playerId)
		{
			PlatformID = playerId.PlatformID;
			Username = playerId.Metadata.Username.GetValueOrEmpty();
			Nickname = playerId.Metadata.Nickname.GetValueOrEmpty();
			Description = playerId.Metadata.Description.GetValueOrEmpty();
			playerId.TryGetPermissionLevel(out var level);
			PermissionLevel = level;
			if (NetworkPlayerManager.TryGetPlayer((byte)playerId, out NetworkPlayer player) && player.HasRig)
			{
				AvatarCrate crate = ((CrateReferenceT<AvatarCrate>)(object)player.RigRefs.RigManager.AvatarCrate).Crate;
				AvatarTitle = ((Scannable)crate).Title;
			}
			AvatarTitle = playerId.Metadata.AvatarTitle.GetValue();
			AvatarModID = playerId.Metadata.AvatarModID.GetValue();
		}
	}
	[Serializable]
	public class PlayerList
	{
		[JsonPropertyName("players")]
		public PlayerInfo[] Players { get; set; } = Array.Empty<PlayerInfo>();


		public void WritePlayers()
		{
			Players = new PlayerInfo[PlayerIDManager.PlayerCount];
			int num = 0;
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				Players[num++] = new PlayerInfo(playerID);
			}
		}
	}
	[Serializable]
	public class ModInfo
	{
		[JsonPropertyName("barcodes")]
		public List<string> Barcodes { get; set; } = new List<string>();


		[JsonPropertyName("modID")]
		public int ModID { get; set; } = -1;


		[JsonPropertyName("nameID")]
		public string NameID { get; set; }
	}
	public sealed class RegistrableList<TRegistrable>
	{
		private readonly HashSet<TRegistrable> _entries = new HashSet<TRegistrable>();

		public HashSet<TRegistrable> Entries => _entries;

		public void Register(TRegistrable entity)
		{
			if (!_entries.Contains(entity))
			{
				_entries.Add(entity);
			}
		}

		public void Unregister(TRegistrable entity)
		{
			_entries.Remove(entity);
		}
	}
	public class SerializedAvatarStats : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 420;

		public Vector3 localScale;

		public float headTop;

		public float chinY;

		public float underbustY;

		public float waistY;

		public float highHipY;

		public float crotchBottom;

		public float headEllipseX;

		public float jawEllipseX;

		public float neckEllipseX;

		public float chestEllipseX;

		public float waistEllipseX;

		public float highHipsEllipseX;

		public float hipsEllipseX;

		public float headEllipseZ;

		public float jawEllipseZ;

		public float neckEllipseZ;

		public float sternumEllipseZ;

		public float chestEllipseZ;

		public float waistEllipseZ;

		public float highHipsEllipseZ;

		public float hipsEllipseZ;

		public float headEllipseNegZ;

		public float jawEllipseNegZ;

		public float neckEllipseNegZ;

		public float sternumEllipseNegZ;

		public float chestEllipseNegZ;

		public float waistEllipseNegZ;

		public float highHipsEllipseNegZ;

		public float hipsEllipseNegZ;

		public SerializedSoftEllipse thighUpperEllipse;

		public SerializedSoftEllipse kneeEllipse;

		public SerializedSoftEllipse calfEllipse;

		public SerializedSoftEllipse ankleEllipse;

		public SerializedSoftEllipse upperarmEllipse;

		public SerializedSoftEllipse elbowEllipse;

		public SerializedSoftEllipse forearmEllipse;

		public SerializedSoftEllipse wristEllipse;

		public float eyeHeight;

		public float heightPercent;

		public float c1HeightPercent;

		public float height;

		public float t1HeightPercent;

		public float skullHeight;

		public float sacrumHeightPercent;

		public float chestHeight;

		public float chestToShoulderPerc;

		public float pelvisHeight;

		public float legUpperPercent;

		public float clavicleLength;

		public float armUpperPercent;

		public float legUpperLength;

		public float armUpperLength;

		public float armLowerPercent;

		public float legLowerPercent;

		public float armLowerLength;

		public float legLowerLength;

		public float carpalPercent;

		public float palmOffsetLength;

		public Vector3 sternumOffsetPercent;

		public float footLength;

		public float carpalLength;

		public float armPercent;

		public float shoulderToPalmPercent;

		public float armLength;

		public float agility;

		public float speed;

		public float strengthUpper;

		public float strengthLower;

		public float vitality;

		public float intelligence;

		public float massArm;

		public float massChest;

		public float massHead;

		public float massLeg;

		public float massPelvis;

		public float massTotal;

		public int? GetSize()
		{
			return 420;
		}

		public SerializedAvatarStats()
		{
		}

		public SerializedAvatarStats(Avatar avatar)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			localScale = ((Component)avatar).transform.localScale;
			headTop = avatar._headTop;
			chinY = avatar._chinY;
			underbustY = avatar._underbustY;
			waistY = avatar._waistY;
			highHipY = avatar._highHipY;
			crotchBottom = avatar._crotchBottom;
			headEllipseX = avatar._headEllipseX;
			jawEllipseX = avatar._jawEllipseX;
			neckEllipseX = avatar._neckEllipseX;
			chestEllipseX = avatar._chestEllipseX;
			waistEllipseX = avatar._waistEllipseX;
			highHipsEllipseX = avatar.HighHipsEllipseX;
			hipsEllipseX = avatar._hipsEllipseX;
			headEllipseZ = avatar._headEllipseZ;
			jawEllipseZ = avatar._jawEllipseZ;
			neckEllipseZ = avatar._neckEllipseZ;
			sternumEllipseZ = avatar._sternumEllipseZ;
			chestEllipseZ = avatar._chestEllipseZ;
			waistEllipseZ = avatar._waistEllipseZ;
			highHipsEllipseZ = avatar._highHipsEllipseZ;
			hipsEllipseZ = avatar._hipsEllipseZ;
			headEllipseNegZ = avatar._headEllipseNegZ;
			jawEllipseNegZ = avatar._jawEllipseNegZ;
			neckEllipseNegZ = avatar._neckEllipseNegZ;
			sternumEllipseNegZ = avatar._sternumEllipseNegZ;
			chestEllipseNegZ = avatar._chestEllipseNegZ;
			waistEllipseNegZ = avatar._waistEllipseNegZ;
			highHipsEllipseNegZ = avatar._highHipsEllipseNegZ;
			hipsEllipseNegZ = avatar._hipsEllipseNegZ;
			thighUpperEllipse = avatar._thighUpperEllipse;
			kneeEllipse = avatar._kneeEllipse;
			calfEllipse = avatar._calfEllipse;
			ankleEllipse = avatar._ankleEllipse;
			upperarmEllipse = avatar._upperarmEllipse;
			elbowEllipse = avatar._elbowEllipse;
			forearmEllipse = avatar._forearmEllipse;
			wristEllipse = avatar._wristEllipse;
			eyeHeight = avatar._eyeHeight;
			heightPercent = avatar._heightPercent;
			c1HeightPercent = avatar._c1HeightPercent;
			height = avatar._height;
			t1HeightPercent = avatar._t1HeightPercent;
			skullHeight = avatar._skullHeight;
			sacrumHeightPercent = avatar._sacrumHeightPercent;
			chestHeight = avatar._chestHeight;
			chestToShoulderPerc = avatar._chestToShoulderPerc;
			pelvisHeight = avatar._pelvisHeight;
			legUpperPercent = avatar._legUpperPercent;
			clavicleLength = avatar._clavicleLength;
			armUpperPercent = avatar._armUpperPercent;
			legUpperLength = avatar._legUpperLength;
			armUpperLength = avatar._armUpperLength;
			armLowerPercent = avatar._armLowerPercent;
			legLowerPercent = avatar._legLowerPercent;
			armLowerLength = avatar._armLowerLength;
			legLowerLength = avatar._legLowerLength;
			carpalPercent = avatar._carpalPercent;
			palmOffsetLength = avatar._palmOffsetLength;
			sternumOffsetPercent = avatar._sternumOffsetPercent;
			footLength = avatar._footLength;
			carpalLength = avatar._carpalLength;
			armPercent = avatar._armPercent;
			shoulderToPalmPercent = avatar._shoulderToPalmPercent;
			armLength = avatar._armLength;
			agility = avatar._agility;
			speed = avatar._speed;
			strengthUpper = avatar._strengthUpper;
			strengthLower = avatar._strengthLower;
			vitality = avatar._vitality;
			intelligence = avatar._intelligence;
			massArm = avatar._massArm;
			massChest = avatar._massChest;
			massHead = avatar._massHead;
			massLeg = avatar._massLeg;
			massPelvis = avatar._massPelvis;
			massTotal = avatar._massTotal;
		}

		public void CopyTo(Avatar avatar)
		{
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			avatar._headTop = headTop;
			avatar._chinY = chinY;
			avatar._underbustY = underbustY;
			avatar._waistY = waistY;
			avatar._highHipY = highHipY;
			avatar._crotchBottom = crotchBottom;
			avatar._headEllipseX = headEllipseX;
			avatar._jawEllipseX = jawEllipseX;
			avatar._neckEllipseX = neckEllipseX;
			avatar._chestEllipseX = chestEllipseX;
			avatar._waistEllipseX = waistEllipseX;
			avatar._highHipsEllipseX = highHipsEllipseX;
			avatar._hipsEllipseX = hipsEllipseX;
			avatar._headEllipseZ = headEllipseZ;
			avatar._jawEllipseZ = jawEllipseZ;
			avatar._neckEllipseZ = neckEllipseZ;
			avatar._sternumEllipseZ = sternumEllipseZ;
			avatar._chestEllipseZ = chestEllipseZ;
			avatar._waistEllipseZ = waistEllipseZ;
			avatar._highHipsEllipseZ = highHipsEllipseZ;
			avatar._hipsEllipseZ = hipsEllipseZ;
			avatar._headEllipseNegZ = headEllipseNegZ;
			avatar._jawEllipseNegZ = jawEllipseNegZ;
			avatar._neckEllipseNegZ = neckEllipseNegZ;
			avatar._sternumEllipseNegZ = sternumEllipseNegZ;
			avatar._chestEllipseNegZ = chestEllipseNegZ;
			avatar._waistEllipseNegZ = waistEllipseNegZ;
			avatar._highHipsEllipseNegZ = highHipsEllipseNegZ;
			avatar._hipsEllipseNegZ = hipsEllipseNegZ;
			avatar._thighUpperEllipse = thighUpperEllipse;
			avatar._kneeEllipse = kneeEllipse;
			avatar._calfEllipse = calfEllipse;
			avatar._ankleEllipse = ankleEllipse;
			avatar._upperarmEllipse = upperarmEllipse;
			avatar._elbowEllipse = elbowEllipse;
			avatar._forearmEllipse = forearmEllipse;
			avatar._wristEllipse = wristEllipse;
			avatar._eyeHeight = eyeHeight;
			avatar._heightPercent = heightPercent;
			avatar._c1HeightPercent = c1HeightPercent;
			avatar._height = height;
			avatar._t1HeightPercent = t1HeightPercent;
			avatar._skullHeight = skullHeight;
			avatar._sacrumHeightPercent = sacrumHeightPercent;
			avatar._chestHeight = chestHeight;
			avatar._chestToShoulderPerc = chestToShoulderPerc;
			avatar._pelvisHeight = pelvisHeight;
			avatar._legUpperPercent = legUpperPercent;
			avatar._clavicleLength = clavicleLength;
			avatar._armUpperPercent = armUpperPercent;
			avatar._legUpperLength = legUpperLength;
			avatar._armUpperLength = armUpperLength;
			avatar._armLowerPercent = armLowerPercent;
			avatar._legLowerPercent = legLowerPercent;
			avatar._armLowerLength = armLowerLength;
			avatar._legLowerLength = legLowerLength;
			avatar._carpalPercent = carpalPercent;
			avatar._palmOffsetLength = palmOffsetLength;
			avatar._sternumOffsetPercent = sternumOffsetPercent;
			avatar._footLength = footLength;
			avatar._carpalLength = carpalLength;
			avatar._armPercent = armPercent;
			avatar._shoulderToPalmPercent = shoulderToPalmPercent;
			avatar._armLength = armLength;
			avatar._agility = agility;
			avatar._speed = speed;
			avatar._strengthUpper = strengthUpper;
			avatar._strengthLower = strengthLower;
			avatar._vitality = vitality;
			avatar._intelligence = intelligence;
			avatar._massArm = massArm;
			avatar._massChest = massChest;
			avatar._massHead = massHead;
			avatar._massLeg = massLeg;
			avatar._massPelvis = massPelvis;
			avatar._massTotal = massTotal;
		}

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerUnityExtensions.SerializeValue(serializer, ref localScale);
			serializer.SerializeValue(ref headTop);
			serializer.SerializeValue(ref chinY);
			serializer.SerializeValue(ref underbustY);
			serializer.SerializeValue(ref waistY);
			serializer.SerializeValue(ref highHipY);
			serializer.SerializeValue(ref crotchBottom);
			serializer.SerializeValue(ref headEllipseX);
			serializer.SerializeValue(ref jawEllipseX);
			serializer.SerializeValue(ref neckEllipseX);
			serializer.SerializeValue(ref chestEllipseX);
			serializer.SerializeValue(ref waistEllipseX);
			serializer.SerializeValue(ref highHipsEllipseX);
			serializer.SerializeValue(ref hipsEllipseX);
			serializer.SerializeValue(ref headEllipseZ);
			serializer.SerializeValue(ref jawEllipseZ);
			serializer.SerializeValue(ref neckEllipseZ);
			serializer.SerializeValue(ref sternumEllipseZ);
			serializer.SerializeValue(ref chestEllipseZ);
			serializer.SerializeValue(ref waistEllipseZ);
			serializer.SerializeValue(ref highHipsEllipseZ);
			serializer.SerializeValue(ref hipsEllipseZ);
			serializer.SerializeValue(ref headEllipseNegZ);
			serializer.SerializeValue(ref jawEllipseNegZ);
			serializer.SerializeValue(ref neckEllipseNegZ);
			serializer.SerializeValue(ref sternumEllipseNegZ);
			serializer.SerializeValue(ref chestEllipseNegZ);
			serializer.SerializeValue(ref waistEllipseNegZ);
			serializer.SerializeValue(ref highHipsEllipseNegZ);
			serializer.SerializeValue(ref hipsEllipseNegZ);
			NetSerializerExtensions.SerializeValue(serializer, ref thighUpperEllipse);
			NetSerializerExtensions.SerializeValue(serializer, ref kneeEllipse);
			NetSerializerExtensions.SerializeValue(serializer, ref calfEllipse);
			NetSerializerExtensions.SerializeValue(serializer, ref ankleEllipse);
			NetSerializerExtensions.SerializeValue(serializer, ref upperarmEllipse);
			NetSerializerExtensions.SerializeValue(serializer, ref elbowEllipse);
			NetSerializerExtensions.SerializeValue(serializer, ref forearmEllipse);
			NetSerializerExtensions.SerializeValue(serializer, ref wristEllipse);
			serializer.SerializeValue(ref eyeHeight);
			serializer.SerializeValue(ref heightPercent);
			serializer.SerializeValue(ref c1HeightPercent);
			serializer.SerializeValue(ref height);
			serializer.SerializeValue(ref t1HeightPercent);
			serializer.SerializeValue(ref skullHeight);
			serializer.SerializeValue(ref sacrumHeightPercent);
			serializer.SerializeValue(ref chestHeight);
			serializer.SerializeValue(ref chestToShoulderPerc);
			serializer.SerializeValue(ref pelvisHeight);
			serializer.SerializeValue(ref legUpperPercent);
			serializer.SerializeValue(ref clavicleLength);
			serializer.SerializeValue(ref armUpperPercent);
			serializer.SerializeValue(ref legUpperLength);
			serializer.SerializeValue(ref armUpperLength);
			serializer.SerializeValue(ref armLowerPercent);
			serializer.SerializeValue(ref legLowerPercent);
			serializer.SerializeValue(ref armLowerLength);
			serializer.SerializeValue(ref legLowerLength);
			serializer.SerializeValue(ref carpalPercent);
			serializer.SerializeValue(ref palmOffsetLength);
			NetSerializerUnityExtensions.SerializeValue(serializer, ref sternumOffsetPercent);
			serializer.SerializeValue(ref footLength);
			serializer.SerializeValue(ref carpalLength);
			serializer.SerializeValue(ref armPercent);
			serializer.SerializeValue(ref shoulderToPalmPercent);
			serializer.SerializeValue(ref armLength);
			serializer.SerializeValue(ref agility);
			serializer.SerializeValue(ref speed);
			serializer.SerializeValue(ref strengthUpper);
			serializer.SerializeValue(ref strengthLower);
			serializer.SerializeValue(ref vitality);
			serializer.SerializeValue(ref intelligence);
			serializer.SerializeValue(ref massArm);
			serializer.SerializeValue(ref massChest);
			serializer.SerializeValue(ref massHead);
			serializer.SerializeValue(ref massLeg);
			serializer.SerializeValue(ref massPelvis);
			serializer.SerializeValue(ref massTotal);
		}
	}
	public class SerializedPlayerSettings : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 16;

		public Color NametagColor;

		public void Serialize(INetSerializer serializer)
		{
			NetSerializerUnityExtensions.SerializeValue(serializer, ref NametagColor);
		}

		public static SerializedPlayerSettings Create()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return new SerializedPlayerSettings
			{
				NametagColor = ClientSettings.NameTagColor
			};
		}
	}
	public class SerializedLocalTransform : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 14;

		public static readonly SerializedLocalTransform Default = new SerializedLocalTransform(Vector3Extensions.zero, QuaternionExtensions.identity);

		public Vector3 position;

		public Quaternion rotation;

		private SerializedShortVector3 _compressedPosition;

		private SerializedSmallQuaternion _compressedRotation;

		public void Serialize(INetSerializer serializer)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (serializer.IsReader)
			{
				NetSerializerExtensions.SerializeValue(serializer, ref _compressedPosition);
				NetSerializerExtensions.SerializeValue(serializer, ref _compressedRotation);
				position = _compressedPosition.Expand();
				rotation = _compressedRotation.Expand();
			}
			else
			{
				_compressedPosition = SerializedShortVector3.Compress(position);
				_compressedRotation = SerializedSmallQuaternion.Compress(rotation);
				NetSerializerExtensions.SerializeValue(serializer, ref _compressedPosition);
				NetSerializerExtensions.SerializeValue(serializer, ref _compressedRotation);
			}
		}

		public SerializedLocalTransform()
		{
		}

		public SerializedLocalTransform(Transform transform)
			: this(transform.localPosition, transform.localRotation)
		{
		}//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)


		public SerializedLocalTransform(Vector3 localPosition, Quaternion localRotation)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			position = localPosition;
			rotation = localRotation;
		}
	}
	public class SerializedQuaternion : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 7;

		public short c1;

		public short c2;

		public short c3;

		public byte loss;

		public const float PRECISION_OFFSET = 10000f;

		public int? GetSize()
		{
			return 7;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref c1);
			serializer.SerializeValue(ref c2);
			serializer.SerializeValue(ref c3);
			serializer.SerializeValue(ref loss);
		}

		public unsafe static SerializedQuaternion Compress(Quaternion quat)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			float* ptr = stackalloc float[4] { quat.x, quat.y, quat.z, quat.w };
			byte b = 0;
			float num = 0f;
			float num2 = 0f;
			for (byte b2 = 0; b2 < 4; b2++)
			{
				if (System.Math.Abs(ptr[(int)b2]) > num)
				{
					num2 = ((!(ptr[(int)b2] < 0f)) ? 1 : (-1));
					b = b2;
					num = ptr[(int)b2];
				}
			}
			short* ptr2 = stackalloc short[3];
			int num3 = 0;
			for (int i = 0; i < 4; i++)
			{
				if (i != b)
				{
					ptr2[num3++] = (short)(ptr[i] * num2 * 10000f);
				}
			}
			return new SerializedQuaternion
			{
				c1 = *ptr2,
				c2 = ptr2[1],
				c3 = ptr2[2],
				loss = b
			};
		}

		public Quaternion Expand()
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			if (loss >= 4)
			{
				throw new DataCorruptionException($"Expanding a quaternion led to a lost component of {loss}!");
			}
			float num = (float)c1 / 10000f;
			float num2 = (float)c2 / 10000f;
			float num3 = (float)c3 / 10000f;
			float num4 = (float)System.Math.Sqrt(1f - Pow(num) - Pow(num2) - Pow(num3));
			return (Quaternion)(loss switch
			{
				0 => new Quaternion(num4, num, num2, num3), 
				1 => new Quaternion(num, num4, num2, num3), 
				2 => new Quaternion(num, num2, num4, num3), 
				3 => new Quaternion(num, num2, num3, num4), 
				_ => QuaternionExtensions.identity, 
			});
			static float Pow(float x)
			{
				return x * x;
			}
		}
	}
	public class SerializedShortVector3 : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 10;

		public short x;

		public short y;

		public short z;

		public float magnitude;

		public int? GetSize()
		{
			return 10;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref x);
			serializer.SerializeValue(ref y);
			serializer.SerializeValue(ref z);
			serializer.SerializeValue(ref magnitude);
		}

		public static SerializedShortVector3 Compress(Vector3 vector)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			Vector3 normalized = ((Vector3)(ref vector)).normalized;
			float num = ((Vector3)(ref vector)).magnitude;
			return new SerializedShortVector3
			{
				x = ToShort(normalized.x),
				y = ToShort(normalized.y),
				z = ToShort(normalized.z),
				magnitude = num
			};
		}

		public Vector3 Expand()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = new Vector3(ToSingle(x), ToSingle(y), ToSingle(z));
			return ((Vector3)(ref val)).normalized * magnitude;
		}

		private static short ToShort(float value)
		{
			return (short)(value * 30000f);
		}

		private static float ToSingle(short value)
		{
			return (float)value / 30000f;
		}
	}
	public class SerializedSmallDirection2D : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 2;

		public sbyte x;

		public sbyte y;

		public int? GetSize()
		{
			return 2;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref x);
			serializer.SerializeValue(ref y);
		}

		public static SerializedSmallDirection2D Compress(Vector2 direction)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			Vector2 normalized = ((Vector2)(ref direction)).normalized;
			return new SerializedSmallDirection2D
			{
				x = normalized.x.ToSByte(),
				y = normalized.y.ToSByte()
			};
		}

		public Vector2 Expand()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(x.ToSingle(), y.ToSingle());
		}
	}
	public class SerializedSmallQuaternion : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 4;

		public static readonly SerializedSmallQuaternion Default = Compress(QuaternionExtensions.identity);

		public sbyte c1;

		public sbyte c2;

		public sbyte c3;

		public sbyte c4;

		public int? GetSize()
		{
			return 4;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref c1);
			serializer.SerializeValue(ref c2);
			serializer.SerializeValue(ref c3);
			serializer.SerializeValue(ref c4);
		}

		public static SerializedSmallQuaternion Compress(Quaternion quat)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			return new SerializedSmallQuaternion
			{
				c1 = quat.x.ToSByte(),
				c2 = quat.y.ToSByte(),
				c3 = quat.z.ToSByte(),
				c4 = quat.w.ToSByte()
			};
		}

		public Quaternion Expand()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = new Quaternion(c1.ToSingle(), c2.ToSingle(), c3.ToSingle(), c4.ToSingle());
			return ((Quaternion)(ref val)).normalized;
		}
	}
	public class SerializedSmallVector2 : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 6;

		public sbyte x;

		public sbyte y;

		public float magnitude;

		public int? GetSize()
		{
			return 6;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref x);
			serializer.SerializeValue(ref y);
			serializer.SerializeValue(ref magnitude);
		}

		public static SerializedSmallVector2 Compress(Vector2 vector)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Vector2 normalized = ((Vector2)(ref vector)).normalized;
			float num = ((Vector2)(ref vector)).magnitude;
			return new SerializedSmallVector2
			{
				x = normalized.x.ToSByte(),
				y = normalized.y.ToSByte(),
				magnitude = num
			};
		}

		public Vector2 Expand()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = new Vector2(x.ToSingle(), y.ToSingle());
			return ((Vector2)(ref val)).normalized * magnitude;
		}
	}
	public class SerializedSmallVector3 : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 7;

		public sbyte x;

		public sbyte y;

		public sbyte z;

		public float magnitude;

		public int? GetSize()
		{
			return 7;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref x);
			serializer.SerializeValue(ref y);
			serializer.SerializeValue(ref z);
			serializer.SerializeValue(ref magnitude);
		}

		public static SerializedSmallVector3 Compress(Vector3 vector)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			Vector3 normalized = ((Vector3)(ref vector)).normalized;
			float num = ((Vector3)(ref vector)).magnitude;
			return new SerializedSmallVector3
			{
				x = normalized.x.ToSByte(),
				y = normalized.y.ToSByte(),
				z = normalized.z.ToSByte(),
				magnitude = num
			};
		}

		public Vector3 Expand()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = new Vector3(x.ToSingle(), y.ToSingle(), z.ToSingle());
			return ((Vector3)(ref val)).normalized * magnitude;
		}
	}
	public class SerializedTransform : LabFusion.Network.Serialization.INetSerializable
	{
		public const ushort Size = 19;

		public static readonly SerializedTransform Default = new SerializedTransform(Vector3Extensions.zero, QuaternionExtensions.identity);

		public Vector3 position;

		public Quaternion rotation;

		private SerializedQuaternion _compressedRotation;

		public int? GetSize()
		{
			return 19;
		}

		public void Serialize(INetSerializer serializer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 value = position;
			if (!serializer.IsReader)
			{
				value = NetworkTransformManager.EncodePosition(value);
			}
			NetSerializerUnityExtensions.SerializeValue(serializer, ref value);
			NetSerializerExtensions.SerializeValue(serializer, ref _compressedRotation);
			if (serializer.IsReader)
			{
				position = NetworkTransformManager.DecodePosition(value);
				rotation = _compressedRotation.Expand();
			}
		}

		public SerializedTransform()
		{
		}

		public SerializedTransform(Transform transform)
			: this(transform.position, transform.rotation)
		{
		}//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)


		public SerializedTransform(Vector3 position, Quaternion rotation)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			this.position = position;
			this.rotation = rotation;
			_compressedRotation = SerializedQuaternion.Compress(this.rotation);
		}
	}
}
namespace LabFusion.Data.Serializables
{
	public class GameObjectReference : LabFusion.Network.Serialization.INetSerializable
	{
		public enum ReferenceType : byte
		{
			Null,
			Entity,
			Scene
		}

		public ReferenceType Type;

		public GameObject GameObject;

		private string _path;

		private NetworkEntityReference _entity;

		private ushort _bodyIndex;

		private MarrowBody _body;

		private Action<GameObject> _callback;

		public NetworkEntityReference? Entity
		{
			get
			{
				if (Type != ReferenceType.Entity)
				{
					return null;
				}
				return _entity;
			}
		}

		public MarrowBody Body => _body;

		public GameObjectReference()
		{
		}

		public GameObjectReference(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				Type = ReferenceType.Null;
				GameObject = null;
				return;
			}
			GameObject = gameObject;
			MarrowBody val = MarrowBody.Cache.Get(gameObject);
			if ((Object)(object)val != (Object)null && MarrowBodyExtender.Cache.TryGet(val, out var value))
			{
				MarrowBodyExtender extender = value.GetExtender<MarrowBodyExtender>();
				Type = ReferenceType.Entity;
				_entity = new NetworkEntityReference(value);
				_bodyIndex = extender.GetIndex(val).Value;
			}
			else
			{
				Type = ReferenceType.Scene;
				_path = gameObject.GetFullPath();
			}
		}

		public int? GetSize()
		{
			int num = 1;
			switch (Type)
			{
			case ReferenceType.Entity:
				num += 2;
				num += 2;
				break;
			case ReferenceType.Scene:
				num += _path.GetSize();
				break;
			}
			return num;
		}

		public void HookGameObjectFound(Action<GameObject> callback)
		{
			if ((Object)(object)GameObject != (Object)null)
			{
				callback(GameObject);
			}
			else
			{
				_callback = (Action<GameObject>)Delegate.Combine(_callback, callback);
			}
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Type);
			switch (Type)
			{
			case ReferenceType.Null:
				if (serializer.IsReader)
				{
					OnGameObjectFound(null);
				}
				break;
			case ReferenceType.Entity:
				NetSerializerExtensions.SerializeValue(serializer, ref _entity);
				serializer.SerializeValue(ref _bodyIndex);
				_entity.HookEntityRegistered(OnEntityRegistered);
				break;
			case ReferenceType.Scene:
				serializer.SerializeValue(ref _path);
				if (serializer.IsReader)
				{
					OnGameObjectFound(GameObjectUtilities.GetGameObject(_path));
				}
				break;
			}
		}

		private void OnEntityRegistered(NetworkEntity entity)
		{
			MarrowBodyExtender extender = entity.GetExtender<MarrowBodyExtender>();
			if (extender == null)
			{
				OnGameObjectFound(null);
				return;
			}
			MarrowBody component = extender.GetComponent(_bodyIndex);
			if ((Object)(object)component == (Object)null)
			{
				OnGameObjectFound(null);
			}
			else
			{
				OnGameObjectFound(((Component)component).gameObject);
			}
		}

		private void OnGameObjectFound(GameObject gameObject)
		{
			GameObject = gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				_body = MarrowBody.Cache.Get(gameObject);
			}
			_callback?.Invoke(gameObject);
			_callback = null;
		}
	}
}
namespace LabFusion.Audio
{
	public static class AudioInfo
	{
		public static readonly int OutputSampleRate = AudioSettings.outputSampleRate;

		public static readonly float ToneVolume = 0.1f;

		public static readonly float ToneNormalizer = 1f / ToneVolume;

		public static AudioClip CreateToneClip()
		{
			return AudioClip.Create("Tone", OutputSampleRate, 1, OutputSampleRate, false, PCMReaderCallback.op_Implicit((Action<Il2CppStructArray<float>>)delegate(Il2CppStructArray<float> data)
			{
				int length = ((Il2CppArrayBase<float>)(object)data).Length;
				for (int i = 0; i < length; i++)
				{
					((Il2CppArrayBase<float>)(object)data)[i] = ToneVolume;
				}
			}));
		}
	}
	public static class AudioOcclusion
	{
		public static readonly int OcclusionMask = -2105676041;

		public const int MaxIteration = 8;

		private static readonly Il2CppStructArray<RaycastHit> _hitBuffer = new Il2CppStructArray<RaycastHit>(32L);

		public static float RaycastOcclusionMultiplier(Vector3 listener, Vector3 source)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			float thickness = 0f;
			if (RaycastWallThickness(listener, source, ref thickness))
			{
				return MathF.Exp(0f - MathF.Sqrt(thickness * 3f));
			}
			return 1f;
		}

		private static bool RaycastWallThickness(Vector3 start, Vector3 end, ref float thickness, int iteration = 0)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (iteration >= 8)
			{
				return false;
			}
			RaycastHit val = default(RaycastHit);
			bool flag = Physics.Linecast(end, start, ref val, OcclusionMask, (QueryTriggerInteraction)1);
			bool flag2 = false;
			RaycastHit hitInfo = default(RaycastHit);
			if (flag)
			{
				flag2 = RaycastClosestToEnd(start, ((RaycastHit)(ref val)).point, ((RaycastHit)(ref val)).rigidbody, out hitInfo);
			}
			if (flag2 && flag)
			{
				float num = thickness;
				Vector3 val2 = ((RaycastHit)(ref hitInfo)).point - ((RaycastHit)(ref val)).point;
				thickness = num + ((Vector3)(ref val2)).magnitude;
				RaycastWallThickness(start, ((RaycastHit)(ref hitInfo)).point, ref thickness, iteration + 1);
				return true;
			}
			return false;
		}

		private static bool RaycastClosestToEnd(Vector3 start, Vector3 end, Rigidbody rigidbody, out RaycastHit hitInfo)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			hitInfo = default(RaycastHit);
			float num = float.PositiveInfinity;
			Vector3 val = end - start;
			int num2 = Physics.RaycastNonAlloc(new Ray(start, ((Vector3)(ref val)).normalized), _hitBuffer, ((Vector3)(ref val)).magnitude, OcclusionMask, (QueryTriggerInteraction)1);
			for (int i = 0; i < num2; i++)
			{
				RaycastHit val2 = ((Il2CppArrayBase<RaycastHit>)(object)_hitBuffer)[i];
				if (!((Object)(object)((RaycastHit)(ref val2)).rigidbody != (Object)(object)rigidbody))
				{
					Vector3 val3 = ((RaycastHit)(ref val2)).point - end;
					float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						num = sqrMagnitude;
						result = true;
						hitInfo = val2;
					}
				}
			}
			return result;
		}
	}
	[RegisterTypeInIl2Cpp]
	public sealed class AudioStreamFilter : MonoBehaviour
	{
		public const int QueueCapacity = 8192;

		public const float NormalizationThreshold = 1f;

		[HideFromIl2Cpp]
		public Queue<float> ReadingQueue { get; } = new Queue<float>(8192);


		[HideFromIl2Cpp]
		public float[] ReadingArray { get; } = new float[AudioInfo.OutputSampleRate];


		[HideFromIl2Cpp]
		public float SampleMultiplier { get; set; } = 1f;


		[HideFromIl2Cpp]
		public float Peak { get; set; } = 1f;


		public AudioStreamFilter(IntPtr intPtr)
			: base(intPtr)
		{
		}

		[HideFromIl2Cpp]
		public void Enqueue(float sample)
		{
			if (ReadingQueue.Count >= 8192)
			{
				ReadingQueue.Dequeue();
			}
			ReadingQueue.Enqueue(sample);
		}

		[HideFromIl2Cpp]
		public void TickPeak(float deltaTime)
		{
			Peak = ManagedMathf.Lerp(Peak, 1f, Smoothing.CalculateDecay(4f, deltaTime));
		}

		[HideFromIl2Cpp]
		public void ClearValues()
		{
			ReadingQueue.Clear();
			Peak = 1f;
		}

		private void OnAudioFilterRead(Il2CppStructArray<float> data, int channels)
		{
			ProcessAudioFilter(data, channels);
		}

		[HideFromIl2Cpp]
		public void ProcessAudioFilter(Il2CppStructArray<float> data, int channels)
		{
			int length = ((Il2CppArrayBase<float>)(object)data).Length;
			int num = length / channels;
			for (int i = 0; i < num; i++)
			{
				float num2 = 0f;
				if (ReadingQueue.Count > 0)
				{
					num2 = ReadingQueue.Dequeue() * SampleMultiplier;
				}
				ReadingArray[i] = num2;
				Peak = MathF.Max(Peak, MathF.Abs(num2));
			}
			float num3 = 1f;
			if (Peak > 1f)
			{
				num3 = 1f / Peak;
			}
			int num4 = 0;
			IntPtr pointer = ((Il2CppObjectBase)data).Pointer;
			int size = IntPtr.Size;
			for (int j = 0; j < length; j += channels)
			{
				float num5 = ReadingArray[num4++];
				for (int k = 0; k < channels; k++)
				{
					int index = j + k;
					float value = InteropUtilities.FloatArrayFastRead(pointer, size, index) * num5 * AudioInfo.ToneNormalizer * num3;
					InteropUtilities.FloatArrayFastWrite(pointer, size, index, value);
				}
			}
		}
	}
}
namespace LabFusion.Marrow
{
	public static class BacklotReferences
	{
		public static SpawnableCrateReference ConstrainerReference { get; set; } = new SpawnableCrateReference(MarrowBarcodes.EmptyBarcode);

	}
	public static class CrateFilterer
	{
		public static int GetModID(Pallet pallet)
		{
			PalletManifest manifest = GetManifest(pallet);
			if (manifest == null)
			{
				return -1;
			}
			ModIOModTarget targetFromListing = ModIOManager.GetTargetFromListing(manifest.ModListing);
			if (targetFromListing == null)
			{
				return -1;
			}
			return (int)targetFromListing.ModId;
		}

		public static PalletManifest GetManifest(Pallet pallet)
		{
			Dictionary<Barcode, PalletManifest> palletManifests = AssetWarehouse.Instance.palletManifests;
			Barcode barcode = ((Scannable)pallet).Barcode;
			if (!palletManifests.ContainsKey(barcode))
			{
				return null;
			}
			return palletManifests[barcode];
		}

		public static bool HasCrate<TCrate>(Barcode barcode) where TCrate : Crate
		{
			if (barcode == (Barcode)null)
			{
				return false;
			}
			AssetWarehouse instance = AssetWarehouse.Instance;
			if (!instance._crateRegistry.ContainsKey(barcode))
			{
				return false;
			}
			return (Object)(object)((Il2CppObjectBase)instance._crateRegistry[barcode]).TryCast<TCrate>() != (Object)null;
		}

		public static TCrate GetCrate<TCrate>(Barcode barcode) where TCrate : Crate
		{
			if (barcode == (Barcode)null)
			{
				return default(TCrate);
			}
			AssetWarehouse instance = AssetWarehouse.Instance;
			if (!instance._crateRegistry.ContainsKey(barcode))
			{
				return default(TCrate);
			}
			return ((Il2CppObjectBase)instance._crateRegistry[barcode]).TryCast<TCrate>();
		}

		public static TCrate[] FilterByTags<TCrate>(Pallet pallet, params string[] tags) where TCrate : Crate
		{
			List<TCrate> list = new List<TCrate>();
			Enumerator<Crate> enumerator = pallet.Crates.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Crate current = enumerator.Current;
				TCrate val = ((Il2CppObjectBase)current).TryCast<TCrate>();
				if (Object.op_Implicit((Object)(object)val) && HasTags(current, tags))
				{
					list.Add(val);
				}
			}
			return list.ToArray();
		}

		public static TCrate[] FilterByTags<TCrate>(params string[] tags) where TCrate : Crate
		{
			List<TCrate> crates = AssetWarehouse.Instance.GetCrates<TCrate>((ICrateFilter<TCrate>)null);
			List<TCrate> list = new List<TCrate>();
			Enumerator<TCrate> enumerator = crates.GetEnumerator();
			while (enumerator.MoveNext())
			{
				TCrate current = enumerator.Current;
				if (HasTags((Crate)(object)current, tags))
				{
					list.Add(current);
				}
			}
			return list.ToArray();
		}

		public static bool HasTags(Crate crate, params string[] tags)
		{
			foreach (string text in tags)
			{
				if (!crate.Tags.Contains(text))
				{
					return false;
				}
			}
			return true;
		}

		public static bool HasTags<TCrate>(Barcode barcode, params string[] tags) where TCrate : Crate
		{
			TCrate crate = GetCrate<TCrate>(barcode);
			if ((Object)(object)crate == (Object)null)
			{
				return false;
			}
			return HasTags((Crate)(object)crate, tags);
		}
	}
	public static class FusionBoneTagReferences
	{
		public static readonly BoneTagReference FusionPlayerReference = new BoneTagReference("Lakatrazz.FusionContent.BoneTag.FusionPlayer");

		public static readonly BoneTagReference TeamLavaGangReference = new BoneTagReference("Lakatrazz.FusionContent.BoneTag.TeamLavaGang");

		public static readonly BoneTagReference TeamSabrelakeReference = new BoneTagReference("Lakatrazz.FusionContent.BoneTag.TeamSabrelake");

		public static readonly BoneTagReference SpectatorReference = new BoneTagReference("Lakatrazz.FusionContent.BoneTag.Spectator");
	}
	public static class FusionLevelReferences
	{
		public static readonly LevelCrateReference LoadDownloadingReference = new LevelCrateReference("Lakatrazz.FusionContent.Level.LoadDownloading");

		public static readonly LevelCrateReference FusionTestingReference = new LevelCrateReference("Lakatrazz.FusionContent.Level.FusionTesting");
	}
	public static class FusionMonoDiscPlaylists
	{
		public static MonoDiscReference[] AmbientPlaylist { get; set; } = Array.Empty<MonoDiscReference>();

	}
	public static class FusionMonoDiscReferences
	{
		public static readonly MonoDiscReference LavaGangVictoryReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.LavaGangTriumphs");

		public static readonly MonoDiscReference LavaGangFailureReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.LavaGangFails");

		public static readonly MonoDiscReference SabrelakeVictoryReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.SabrelakeTriumphs");

		public static readonly MonoDiscReference SabrelakeFailureReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.SabrelakeFails");

		public static readonly MonoDiscReference ErmReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.Erm");

		public static readonly MonoDiscReference FistfightFusionReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.FistfightFusion");

		public static readonly MonoDiscReference GeoGrpFellDownTheStairsReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.GeoGrpFellDownTheStairs");

		public static readonly MonoDiscReference[] CombatSongReferences = (MonoDiscReference[])(object)new MonoDiscReference[6]
		{
			new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.BuggyPhysics"),
			new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.SicklyBugInitiative"),
			new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.SyntheticCaverns"),
			new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.WackyWillysWonderland"),
			new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.SmigglesInDespair"),
			new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.AppenBeyuge")
		};

		public static readonly MonoDiscReference DeathExplosionReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.DeathExplosion");

		public static readonly MonoDiscReference BitGetReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.BitGet");

		public static readonly MonoDiscReference FailedPurchaseReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.FailedPurchase");

		public static readonly MonoDiscReference SuccessfulPurchaseReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.SuccessfulPurchase");

		public static readonly MonoDiscReference EquipItemReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.EquipItem");

		public static readonly MonoDiscReference UnequipItemReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.UnequipItem");

		public static readonly MonoDiscReference LaserPrismaticSFXReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.LaserPrismaticSFX");

		public static readonly MonoDiscReference LaserPulseReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.LaserPulse");

		public static readonly MonoDiscReference LaserRayDespawnReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.LaserRayDespawn");

		public static readonly MonoDiscReference LaserRaySpawnReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.LaserRaySpawn");

		public static readonly MonoDiscReference UIConfirmReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.UIConfirm");

		public static readonly MonoDiscReference UIDenyReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.UIDeny");

		public static readonly MonoDiscReference UISelectReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.UISelect");

		public static readonly MonoDiscReference UITurnOffReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.UITurnOff");

		public static readonly MonoDiscReference UITurnOnReference = new MonoDiscReference("Lakatrazz.FusionContent.MonoDisc.UITurnOn");
	}
	public static class FusionPalletReferences
	{
		public enum PalletStatus
		{
			MISSING,
			OUTDATED,
			FOUND
		}

		public static readonly PalletReference FusionContentReference = new PalletReference("Lakatrazz.FusionContent");

		public static readonly PalletReference FusionCosmeticsReference = new PalletReference("Lakatrazz.FusionCosmetics");

		public static readonly Version MinimumContentVersion = new Version(1, 3, 0);

		public static PalletStatus ValidatePallet(PalletReference palletReference, Version minimumVersion)
		{
			Enumerator<Pallet> enumerator = AssetWarehouse.Instance.GetPallets().GetEnumerator();
			while (enumerator.MoveNext())
			{
				Pallet current = enumerator.Current;
				if (!(((Scannable)current).Barcode != ((ScannableReference)palletReference).Barcode))
				{
					if (new Version(current.Version) < minimumVersion)
					{
						return PalletStatus.OUTDATED;
					}
					return PalletStatus.FOUND;
				}
			}
			return PalletStatus.MISSING;
		}

		public static PalletStatus ValidateContentPallet()
		{
			return ValidatePallet(FusionContentReference, MinimumContentVersion);
		}
	}
	public static class FusionSpawnableReferences
	{
		public static readonly SpawnableCrateReference BitMartReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.BitMart");

		public static readonly SpawnableCrateReference AchievementBoardReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.AchievementBoard");

		public static readonly SpawnableCrateReference InfoBoardReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.InfoBoard");

		public static readonly SpawnableCrateReference VictoryTrophyReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.VictoryTrophy");

		public static readonly SpawnableCrateReference AchievementPopupReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.AchievementPopup");

		public static readonly SpawnableCrateReference BitPopupReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.BitPopup");

		public static readonly SpawnableCrateReference ProgressBarReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.ProgressBar");

		public static readonly SpawnableCrateReference HealthBarReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.HealthBar");

		public static readonly SpawnableCrateReference LivesBarReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.LivesBar");

		public static readonly SpawnableCrateReference NameTagReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.NameTag");

		public static readonly SpawnableCrateReference HeadLayoutReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.HeadLayout");

		public static readonly SpawnableCrateReference MuteIndicatorReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.MuteIndicator");

		public static readonly SpawnableCrateReference IconReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.Icon");

		public static readonly SpawnableCrateReference FusionMenuReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.FusionMenu");

		public static readonly SpawnableCrateReference DeathExplosionReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.DeathExplosion");

		public static readonly SpawnableCrateReference LaserCursorReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.LaserCursor");

		public static readonly SpawnableCrateReference EntangledLineReference = new SpawnableCrateReference("Lakatrazz.FusionContent.Spawnable.EntangledLine");
	}
	public static class FusionTags
	{
		public const string SingleplayerOnly = "Singleplayer Only";

		public const string Fusion = "Fusion";

		public const string Cosmetic = "Cosmetic";
	}
	public static class MarrowBarcodes
	{
		public static readonly string EmptyBarcode = Barcode.EMPTY;
	}
	public static class MarrowBoneTagReferences
	{
		public static readonly BoneTagReference PlayerReference = new BoneTagReference("SLZ.Marrow.BoneTag.Player");
	}
	public static class MarrowGameReferences
	{
		public static AvatarCrateReference CalibrationAvatarReference { get; set; } = new AvatarCrateReference(MarrowBarcodes.EmptyBarcode);


		public static float CalibrationAvatarHeight { get; set; } = 1.76f;

	}
	public static class AudioLoader
	{
		[CompilerGenerated]
		private sealed class <LoadMonoDiscsCoroutine>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MonoDiscReference[] references;

			public Action<AudioClip[]> loadCallback;

			private AudioClip[] <clips>5__2;

			private int <i>5__3;

			private UniTask<AudioClip> <loadTask>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LoadMonoDiscsCoroutine>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<clips>5__2 = null;
				<loadTask>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_007c;
				}
				<>1__state = -1;
				<clips>5__2 = (AudioClip[])(object)new AudioClip[references.Length];
				<i>5__3 = 0;
				goto IL_00b8;
				IL_00b8:
				if (<i>5__3 < references.Length)
				{
					MonoDisc dataCard = ((DataCardReference<MonoDisc>)(object)references[<i>5__3]).DataCard;
					if (!((Object)(object)dataCard == (Object)null))
					{
						<loadTask>5__4 = dataCard.AudioClip.LoadAssetAsync();
						goto IL_007c;
					}
					goto IL_00a8;
				}
				loadCallback(<clips>5__2);
				return false;
				IL_00a8:
				<i>5__3++;
				goto IL_00b8;
				IL_007c:
				if ((int)<loadTask>5__4.Status == 0)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				<clips>5__2[<i>5__3] = <loadTask>5__4.result;
				<loadTask>5__4 = null;
				goto IL_00a8;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static void LoadMonoDisc(MonoDiscReference reference, Action<AudioClip> loadCallback)
		{
			MonoDisc dataCard = ((DataCardReference<MonoDisc>)(object)reference).DataCard;
			if (!((Object)(object)dataCard == (Object)null))
			{
				dataCard.AudioClip.LoadAsset(Action<AudioClip>.op_Implicit(loadCallback));
			}
		}

		public static void LoadMonoDiscs(MonoDiscReference[] references, Action<AudioClip[]> loadCallback)
		{
			MelonCoroutines.Start(LoadMonoDiscsCoroutine(references, loadCallback));
		}

		[IteratorStateMachine(typeof(<LoadMonoDiscsCoroutine>d__2))]
		private static IEnumerator LoadMonoDiscsCoroutine(MonoDiscReference[] references, Action<AudioClip[]> loadCallback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadMonoDiscsCoroutine>d__2(0)
			{
				references = references,
				loadCallback = loadCallback
			};
		}
	}
	public struct AudioReference
	{
		public MonoDiscReference MonoDisc { get; set; }

		public AudioClip ClipOverride { get; set; }

		public AudioReference(MonoDiscReference monoDisc)
		{
			MonoDisc = monoDisc;
			ClipOverride = null;
		}

		public AudioReference(AudioClip clipOverride)
		{
			ClipOverride = clipOverride;
			MonoDisc = null;
		}

		public readonly bool HasClip()
		{
			bool num = MonoDisc != null && ((ScannableReference)MonoDisc).IsValid();
			bool flag = (Object)(object)ClipOverride != (Object)null;
			return num || flag;
		}

		public readonly void LoadClip(Action<AudioClip> loadCallback)
		{
			if ((Object)(object)ClipOverride != (Object)null)
			{
				loadCallback?.Invoke(ClipOverride);
			}
			else
			{
				AudioLoader.LoadMonoDisc(MonoDisc, loadCallback);
			}
		}

		public static AudioReference[] CreateReferences(MonoDiscReference[] discs)
		{
			AudioReference[] array = new AudioReference[discs.Length];
			for (int i = 0; i < discs.Length; i++)
			{
				array[i] = new AudioReference(discs[i]);
			}
			return array;
		}

		public static AudioReference[] CreateReferences(AudioClip[] clips)
		{
			AudioReference[] array = new AudioReference[clips.Length];
			for (int i = 0; i < clips.Length; i++)
			{
				array[i] = new AudioReference(clips[i]);
			}
			return array;
		}
	}
	public class AudioPlayerSettings
	{
		public static readonly AudioPlayerSettings Default = new AudioPlayerSettings();

		public AudioMixerGroup Mixer { get; set; }

		public float Volume { get; set; } = 1f;


		public float Pitch { get; set; } = 1f;


		public float MinDistance { get; set; } = 1f;


		public float SpatialBlend { get; set; } = 1f;

	}
	public static class LocalAudioPlayer
	{
		public const float MusicVolume = 0.2f;

		public static AudioPlayerSettings SFXSettings => new AudioPlayerSettings
		{
			Mixer = HardInteraction,
			Volume = 0.4f
		};

		public static AudioPlayerSettings InHeadSettings => new AudioPlayerSettings
		{
			Mixer = InHead
		};

		public static AudioPlayerSettings MusicSettings => new AudioPlayerSettings
		{
			Mixer = NonDiegeticMusic,
			Volume = 0.2f
		};

		public static AudioMixerGroup NonDiegeticMusic => Audio3dManager.nonDiegeticMusic;

		public static AudioMixerGroup HardInteraction => Audio3dManager.hardInteraction;

		public static AudioMixerGroup SoftInteraction => Audio3dManager.softInteraction;

		public static AudioMixerGroup InHead => Audio3dManager.inHead;

		public static AudioMixerGroup Vocals => Audio3dManager.npcVocals;

		public static void Play2dOneShot(AudioClip clip, AudioPlayerSettings settings)
		{
			Audio3dManager.Play2dOneShot(clip, settings.Mixer, new Nullable<float>(settings.Volume), new Nullable<float>(settings.Pitch));
		}

		public static void Play2dOneShot(AudioReference reference, AudioPlayerSettings settings)
		{
			if (reference.HasClip())
			{
				reference.LoadClip(delegate(AudioClip clip)
				{
					Play2dOneShot(clip, settings);
				});
			}
		}

		public static void PlayAtPoint(AudioClip[] clips, Vector3 position, AudioPlayerSettings settings)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Audio3dManager.PlayAtPoint(Il2CppReferenceArray<AudioClip>.op_Implicit(clips), position, settings.Mixer, settings.Volume, settings.Pitch, new Nullable<float>(0f), new Nullable<float>(settings.MinDistance), new Nullable<float>(settings.SpatialBlend));
		}

		public static void PlayAtPoint(AudioReference[] references, Vector3 position, AudioPlayerSettings settings)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (references != null && references.Length != 0)
			{
				PlayAtPoint(references.GetRandom(), position, settings);
			}
		}

		public static void PlayAtPoint(AudioClip clip, Vector3 position, AudioPlayerSettings settings)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Audio3dManager.PlayAtPoint(clip, position, settings.Mixer, settings.Volume, settings.Pitch, new Nullable<float>(0f), new Nullable<float>(settings.MinDistance), new Nullable<float>(settings.SpatialBlend));
		}

		public static void PlayAtPoint(AudioReference reference, Vector3 position, AudioPlayerSettings settings)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (reference.HasClip())
			{
				reference.LoadClip(delegate(AudioClip clip)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					PlayAtPoint(clip, position, settings);
				});
			}
		}
	}
	public static class GameObjectHasher
	{
		public static int GetFastHash(GameObject gameObject)
		{
			Transform transform = gameObject.transform;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(((Object)transform).name);
			stringBuilder.Append(transform.GetSiblingIndex());
			if ((Object)(object)transform.parent != (Object)null)
			{
				stringBuilder.Append(((Object)transform.parent).name);
			}
			return stringBuilder.ToString().GetDeterministicHashCode();
		}

		public static int GetHierarchyHash(GameObject gameObject)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = gameObject.transform;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(((Object)transform).name);
			stringBuilder.Append(transform.GetSiblingIndex());
			Scene scene = gameObject.scene;
			stringBuilder.Append(((Scene)(ref scene)).name);
			Transform parent = transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				stringBuilder.Append(((Object)parent).name);
				parent = parent.parent;
			}
			return stringBuilder.ToString().GetDeterministicHashCode();
		}
	}
	public static class MarrowEntityHelper
	{
		public static MarrowEntity GetEntityFromData(ComponentHashData data)
		{
			return MarrowEntityPatches.HashTable.GetComponentFromData(data);
		}

		public static ComponentHashData GetDataFromEntity(MarrowEntity entity)
		{
			return MarrowEntityPatches.HashTable.GetDataFromComponent(entity);
		}

		public static bool IsHashed(MarrowEntity entity)
		{
			return MarrowEntityPatches.HashTable.IsHashed(entity);
		}
	}
	public static class MarrowConstants
	{
		public const float StandardHeight = 1.76f;
	}
	public class MarrowModule : LabFusion.SDK.Modules.Module
	{
		public override string Name => "Marrow";

		public override string Author => "Lakatrazz";

		public override Version Version => FusionMod.Version;

		public override ConsoleColor Color => ConsoleColor.White;

		protected override void OnModuleRegistered()
		{
			ModuleMessageManager.RegisterHandler<ButtonChargeMessage>();
			ModuleMessageManager.RegisterHandler<EventActuatorMessage>();
			ModuleMessageManager.RegisterHandler<GunShotMessage>();
			ModuleMessageManager.RegisterHandler<PuppetMasterKillMessage>();
			ModuleMessageManager.RegisterHandler<InventoryAmmoReceiverDropMessage>();
			ModuleMessageManager.RegisterHandler<InventorySlotDropMessage>();
			ModuleMessageManager.RegisterHandler<InventorySlotInsertMessage>();
			ModuleMessageManager.RegisterHandler<ConstrainerModeMessage>();
			ModuleMessageManager.RegisterHandler<ConstraintCreateMessage>();
			ModuleMessageManager.RegisterHandler<ConstraintDeleteMessage>();
			ModuleMessageManager.RegisterHandler<MagazineClaimMessage>();
			ModuleMessageManager.RegisterHandler<MagazineEjectMessage>();
			ModuleMessageManager.RegisterHandler<MagazineInsertMessage>();
			ModuleMessageManager.RegisterHandler<NimbusGunNoClipMessage>();
			ModuleMessageManager.RegisterHandler<ObjectDestructibleDestroyMessage>();
			ModuleMessageManager.RegisterHandler<CrateSpawnerMessage>();
			MultiplayerHooking.OnMainSceneInitialized += NetworkGunManager.OnMainSceneInitialized;
			LevelEventHandler.OnInitializeMelon();
			if (PlatformHelper.IsAndroid)
			{
				CrateSpawnerAndroidPatches.PatchAll();
			}
			else
			{
				CrateSpawnerPatches.PatchAll();
			}
		}

		protected override void OnModuleUnregistered()
		{
		}
	}
	public static class PooleeHelper
	{
		[CompilerGenerated]
		private sealed class <CoDespawnDelayed>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public float seconds;

			public Poolee poolee;

			private float <elapsed>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <CoDespawnDelayed>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<elapsed>5__2 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__2 < seconds)
				{
					<elapsed>5__2 += TimeReferences.DeltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				poolee.Despawn();
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static void DespawnDelayed(Poolee poolee, float seconds)
		{
			MelonCoroutines.Start(CoDespawnDelayed(poolee, seconds));
		}

		[IteratorStateMachine(typeof(<CoDespawnDelayed>d__1))]
		private static IEnumerator CoDespawnDelayed(Poolee poolee, float seconds)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoDespawnDelayed>d__1(0)
			{
				poolee = poolee,
				seconds = seconds
			};
		}
	}
}
namespace LabFusion.Marrow.Integration
{
	[RegisterTypeInIl2Cpp]
	public class AnimatorSyncer : MonoBehaviour
	{
		public static readonly ComponentHashTable<AnimatorSyncer> HashTable = new ComponentHashTable<AnimatorSyncer>();

		public const float MaxDesyncSeconds = 0.05f;

		[HideFromIl2Cpp]
		public Animator Animator { get; set; }

		[HideFromIl2Cpp]
		public bool HasEntity { get; set; }

		[HideFromIl2Cpp]
		public bool IsOwner { get; set; }

		public AnimatorSyncer(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			Animator = ((Component)this).GetComponent<Animator>();
			int hierarchyHash = GameObjectHasher.GetHierarchyHash(((Component)this).gameObject);
			HashTable.AddComponent(hierarchyHash, this);
		}

		private void OnDestroy()
		{
			HashTable.RemoveComponent(this);
		}

		private void Update()
		{
			if (NetworkSceneManager.IsLevelNetworked)
			{
				bool flag = ((!HasEntity) ? NetworkSceneManager.IsLevelHost : IsOwner);
				if (flag && NetworkTickManager.IsTickThisFrame)
				{
					SyncLayers();
				}
			}
		}

		[HideFromIl2Cpp]
		public void ApplyAnimationState(AnimationStateData data)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			int stateNameHash = data.StateNameHash;
			int layer = data.Layer;
			float normalizedTime = data.NormalizedTime;
			AnimatorStateInfo currentAnimatorStateInfo = Animator.GetCurrentAnimatorStateInfo(layer);
			if (((AnimatorStateInfo)(ref currentAnimatorStateInfo)).shortNameHash == stateNameHash)
			{
				float length = ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).length;
				if (MathF.Abs((normalizedTime - ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).normalizedTime) * length) <= 0.05f)
				{
					return;
				}
			}
			Animator.Play(data.StateNameHash, data.Layer, data.NormalizedTime);
		}

		private void SyncLayers()
		{
			for (int i = 0; i < Animator.layerCount; i++)
			{
				SyncLayer(i);
			}
		}

		private void SyncLayer(int layer)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			AnimatorStateInfo currentAnimatorStateInfo = Animator.GetCurrentAnimatorStateInfo(layer);
			int shortNameHash = ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).shortNameHash;
			float normalizedTime = ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).normalizedTime;
			MessageRelay.RelayModule<AnimationStateMessage, AnimationStateData>(new AnimationStateData
			{
				ComponentData = ComponentPathData.CreateFromComponent<AnimatorSyncer, AnimatorSyncerExtender>(this, HashTable, AnimatorSyncerExtender.Cache),
				StateNameHash = shortNameHash,
				Layer = layer,
				NormalizedTime = normalizedTime
			}, CommonMessageRoutes.UnreliableToOtherClients);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class AvatarCosmeticPoint : MonoBehaviour
	{
		public Il2CppValueField<int> cosmeticPoint;

		public AvatarCosmeticPoint(IntPtr intPtr)
			: base(intPtr)
		{
		}
	}
	[RegisterTypeInIl2Cpp]
	public class CosmeticRoot : MonoBehaviour
	{
		public Il2CppValueField<int> cosmeticPoint;

		public Il2CppValueField<bool> hiddenInView;

		public Il2CppValueField<bool> hiddenInShop;

		public Il2CppValueField<int> rawPrice;

		public Il2CppReferenceField<Texture2D> previewIcon;

		public CosmeticRoot(IntPtr intPtr)
			: base(intPtr)
		{
		}
	}
	public enum RigPoint
	{
		HEAD,
		HEAD_TOP,
		EYE_LEFT,
		EYE_RIGHT,
		EYE_CENTER,
		NOSE,
		CHEST,
		CHEST_BACK,
		HIPS,
		LOCOSPHERE
	}
	[RegisterTypeInIl2Cpp]
	public class DeathTrigger : MonoBehaviour
	{
		public static bool? KillDamageOverride { get; set; }

		public static event Action OnKillPlayer;

		public DeathTrigger(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			((Component)this).gameObject.layer = 29;
		}

		private void OnTriggerEnter(Collider other)
		{
			if (!NetworkInfo.HasServer)
			{
				return;
			}
			Tracker val = Tracker.Cache.Get(((Component)other).gameObject);
			if (!((Object)(object)val == (Object)null))
			{
				MarrowEntity entity = val.Entity;
				if (!((Object)(object)entity == (Object)null) && IMarrowEntityExtender.Cache.TryGet(entity, out var value))
				{
					OnNetworkEntityEnter(value);
				}
			}
		}

		private static void OnNetworkEntityEnter(NetworkEntity networkEntity)
		{
			NetworkPlayer extender = networkEntity.GetExtender<NetworkPlayer>();
			if (extender != null)
			{
				OnNetworkPlayerEnter(networkEntity, extender);
			}
			else if (networkEntity.GetExtender<NetworkProp>() != null)
			{
				OnNetworkPropEnter(networkEntity);
			}
		}

		private static void OnNetworkPlayerEnter(NetworkEntity networkEntity, NetworkPlayer networkPlayer)
		{
			if (networkEntity.IsOwner)
			{
				Player_Health health = networkPlayer.RigRefs.Health;
				if (!KillDamageOverride.HasValue || KillDamageOverride.Value)
				{
					health.ApplyKillDamage();
				}
				DeathTrigger.OnKillPlayer?.InvokeSafe("executing OnKillPlayer hook");
			}
		}

		private static void OnNetworkPropEnter(NetworkEntity networkEntity)
		{
			if (NetworkInfo.IsHost)
			{
				NetworkAssetSpawner.DespawnRequestInfo info = default(NetworkAssetSpawner.DespawnRequestInfo);
				info.EntityID = networkEntity.ID;
				info.DespawnEffect = true;
				NetworkAssetSpawner.Despawn(info);
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public class Desyncer : MonoBehaviour
	{
		public static FusionComponentCache<GameObject, Desyncer> Cache { get; } = new FusionComponentCache<GameObject, Desyncer>();


		public Desyncer(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			Cache.Add(((Component)this).gameObject, this);
		}

		private void OnDestroy()
		{
			Cache.Remove(((Component)this).gameObject);
		}
	}
	[RegisterTypeInIl2Cpp]
	public sealed class CelebrationEvents : MonoBehaviour
	{
		public Il2CppReferenceField<UltEventHolder> onModBirthdayHolder;

		public CelebrationEvents(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Start()
		{
			if (FusionSpecialDates.GetCurrentDate() == FusionSpecialDates.FusionDate.FUSION_BIRTHDAY)
			{
				UltEventHolder obj = onModBirthdayHolder.Get();
				if (obj != null)
				{
					obj.Invoke();
				}
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public class OwnershipEvents : MonoBehaviour
	{
		public Il2CppReferenceField<UltEventHolder> onOwnershipGainedHolder;

		public Il2CppReferenceField<UltEventHolder> onOwnershipLostHolder;

		private bool _isOwner;

		private bool _hasSetOwner;

		[HideFromIl2Cpp]
		public NetworkEntity Entity { get; set; }

		public OwnershipEvents(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void OnOwnerChanged(bool owner)
		{
			if (_hasSetOwner && owner == _isOwner)
			{
				return;
			}
			_isOwner = owner;
			_hasSetOwner = true;
			if (owner)
			{
				UltEventHolder obj = onOwnershipGainedHolder.Get();
				if (obj != null)
				{
					obj.Invoke();
				}
			}
			else
			{
				UltEventHolder obj2 = onOwnershipLostHolder.Get();
				if (obj2 != null)
				{
					obj2.Invoke();
				}
			}
		}

		public bool IsOwner()
		{
			return _isOwner;
		}

		public void TakeOwnership()
		{
			if (Entity != null)
			{
				NetworkEntityManager.TakeOwnership(Entity);
			}
		}

		public int GetOwner()
		{
			if (Entity == null || !Entity.HasOwner)
			{
				return -1;
			}
			return Entity.OwnerID.SmallID;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class PlayerEvents : MonoBehaviour
	{
		public Il2CppReferenceField<UltEventHolder> onPlayerLoadedHolder;

		public Il2CppReferenceField<UltEventHolder> onPlayerUnloadedHolder;

		public Il2CppReferenceField<UltEventHolder> onAllPlayersLoadedHolder;

		public Il2CppReferenceField<UltEventHolder> onPlayerDeathHolder;

		private int _latestPlayerID = -1;

		public PlayerEvents(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			NetworkSceneManager.OnPlayerLoadedIntoLevel += OnPlayerLoadedIntoLevel;
			NetworkSceneManager.OnPlayerStartedLoading += OnPlayerStartedLoading;
			NetworkSceneManager.OnAllPlayersLoaded += OnAllPlayersLoaded;
			MultiplayerHooking.OnPlayerLeft += OnPlayerLeft;
			MultiplayerHooking.OnPlayerAction += OnPlayerAction;
		}

		private void OnDestroy()
		{
			NetworkSceneManager.OnPlayerLoadedIntoLevel -= OnPlayerLoadedIntoLevel;
			NetworkSceneManager.OnPlayerStartedLoading -= OnPlayerStartedLoading;
			NetworkSceneManager.OnAllPlayersLoaded -= OnAllPlayersLoaded;
			MultiplayerHooking.OnPlayerLeft -= OnPlayerLeft;
		}

		[HideFromIl2Cpp]
		private void OnPlayerLoadedIntoLevel(PlayerID playerID, string barcode)
		{
			if (!(barcode != FusionSceneManager.Barcode))
			{
				_latestPlayerID = playerID.SmallID;
				UltEventHolder obj = onPlayerLoadedHolder.Get();
				if (obj != null)
				{
					obj.Invoke();
				}
			}
		}

		[HideFromIl2Cpp]
		private void OnPlayerStartedLoading(PlayerID playerID)
		{
			_latestPlayerID = playerID.SmallID;
			UltEventHolder obj = onPlayerUnloadedHolder.Get();
			if (obj != null)
			{
				obj.Invoke();
			}
		}

		[HideFromIl2Cpp]
		private void OnAllPlayersLoaded()
		{
			_latestPlayerID = -1;
			UltEventHolder obj = onAllPlayersLoadedHolder.Get();
			if (obj != null)
			{
				obj.Invoke();
			}
		}

		[HideFromIl2Cpp]
		private void OnPlayerLeft(PlayerID playerID)
		{
			if (!playerID.Metadata.Loading.GetValue())
			{
				_latestPlayerID = playerID.SmallID;
				UltEventHolder obj = onPlayerUnloadedHolder.Get();
				if (obj != null)
				{
					obj.Invoke();
				}
			}
		}

		[HideFromIl2Cpp]
		private void OnPlayerAction(PlayerID playerID, PlayerActionType type, PlayerID otherPlayer = null)
		{
			if (NetworkSceneManager.InCurrentLevel(playerID) && type == PlayerActionType.DEATH)
			{
				_latestPlayerID = playerID.SmallID;
				UltEventHolder obj = onPlayerDeathHolder.Get();
				if (obj != null)
				{
					obj.Invoke();
				}
			}
		}

		public int GetLatestPlayerID()
		{
			return _latestPlayerID;
		}

		public string GetPlayerUsername(int playerID)
		{
			if (!NetworkInfo.HasServer)
			{
				return string.Empty;
			}
			PlayerID playerID2 = PlayerIDManager.GetPlayerID((byte)playerID);
			if (playerID2 == null)
			{
				return string.Empty;
			}
			return playerID2.Metadata.Username.GetValueOrEmpty();
		}

		public int GetLocalPlayerID()
		{
			if (!NetworkInfo.HasServer)
			{
				return -1;
			}
			return PlayerIDManager.LocalSmallID;
		}

		public int GetHostID()
		{
			if (!NetworkInfo.HasServer)
			{
				return -1;
			}
			return 0;
		}

		public int GetLevelHostID()
		{
			return GetHostID();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class ServerEvents : MonoBehaviour
	{
		public Il2CppReferenceField<UltEventHolder> onServerJoinedHolder;

		public Il2CppReferenceField<UltEventHolder> onServerLeftHolder;

		public ServerEvents(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			MultiplayerHooking.OnJoinedServer += OnServerJoined;
			MultiplayerHooking.OnStartedServer += OnServerJoined;
			MultiplayerHooking.OnDisconnected += OnServerLeft;
			if (HasServer())
			{
				OnServerJoined();
			}
		}

		private void OnDestroy()
		{
			MultiplayerHooking.OnJoinedServer -= OnServerJoined;
			MultiplayerHooking.OnStartedServer -= OnServerJoined;
			MultiplayerHooking.OnDisconnected -= OnServerLeft;
		}

		private void OnServerJoined()
		{
			UltEventHolder obj = onServerJoinedHolder.Get();
			if (obj != null)
			{
				obj.Invoke();
			}
		}

		private void OnServerLeft()
		{
			UltEventHolder obj = onServerLeftHolder.Get();
			if (obj != null)
			{
				obj.Invoke();
			}
		}

		public bool IsHost()
		{
			return NetworkInfo.IsHost;
		}

		public bool HasServer()
		{
			return NetworkInfo.HasServer;
		}

		public string GetServerName()
		{
			if (!NetworkInfo.HasServer)
			{
				return null;
			}
			return LobbyInfoManager.LobbyInfo.LobbyName;
		}

		public int GetPlayerCount()
		{
			return PlayerIDManager.PlayerCount;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class BitTransactor : MonoBehaviour
	{
		public BitTransactor(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void GiveBits(int count)
		{
			PointItemManager.RewardBits(count);
		}

		public void TakeBits(int count)
		{
			PointItemManager.DecrementBits(count);
		}

		public int GetBitCount()
		{
			return PointItemManager.GetBitCount();
		}

		public bool HasBits(int count)
		{
			return count <= GetBitCount();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class GamemodeCrateSpawner : MonoBehaviour
	{
		private CrateSpawner _crateSpawner;

		private Poolee _spawnedPoolee;

		public GamemodeCrateSpawner(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			_crateSpawner = ((Component)this).GetComponent<CrateSpawner>();
			_crateSpawner.manualMode = true;
			((UltEvent<CrateSpawner, GameObject>)(object)_crateSpawner.onSpawnEvent).DynamicCalls += Action<CrateSpawner, GameObject>.op_Implicit((Action<CrateSpawner, GameObject>)OnSpawnEvent);
			GamemodeManager.OnGamemodeStarted += OnGamemodeStarted;
			GamemodeManager.OnGamemodeStopped += OnGamemodeStopped;
		}

		private void OnDestroy()
		{
			GamemodeManager.OnGamemodeStarted -= OnGamemodeStarted;
			GamemodeManager.OnGamemodeStopped -= OnGamemodeStopped;
		}

		private void OnSpawnEvent(CrateSpawner spawner, GameObject spawned)
		{
			_spawnedPoolee = spawned.GetComponent<Poolee>();
		}

		[HideFromIl2Cpp]
		private void OnGamemodeStarted()
		{
			Spawn();
		}

		[HideFromIl2Cpp]
		private void OnGamemodeStopped()
		{
			Despawn();
		}

		private void Spawn()
		{
			if ((Object)(object)_spawnedPoolee != (Object)null)
			{
				Despawn();
			}
			_crateSpawner.SpawnSpawnable();
		}

		private void Despawn()
		{
			if (!((Object)(object)_spawnedPoolee == (Object)null))
			{
				_spawnedPoolee.Despawn();
				_spawnedPoolee = null;
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public class GamemodeDropper : MonoBehaviour
	{
		public static List<Poolee> DroppedItems { get; private set; } = new List<Poolee>();


		public static int DroppedItemCount => DroppedItems.Count;

		public static List<GamemodeDropper> Droppers { get; private set; } = new List<GamemodeDropper>();


		public static bool HasDroppers => Droppers.Count > 0;

		public GamemodeDropper(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			Droppers.Add(this);
		}

		private void OnDestroy()
		{
			Droppers.Remove(this);
		}

		public static bool DropItem()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			if (!NetworkInfo.IsHost)
			{
				return false;
			}
			if (!HasDroppers)
			{
				return false;
			}
			GamemodeDropperSettings.ItemDrop itemDrop = GamemodeDropperSettings.GetItemDrop();
			GamemodeDropper random = Droppers.GetRandom();
			NetworkAssetSpawner.SpawnRequestInfo info = default(NetworkAssetSpawner.SpawnRequestInfo);
			info.Position = ((Component)random).transform.position;
			info.Rotation = ((Component)random).transform.rotation;
			info.Spawnable = new Spawnable
			{
				crateRef = itemDrop.ItemCrateReference,
				policyData = null
			};
			info.SpawnEffect = true;
			info.SpawnCallback = OnItemSpawned;
			NetworkAssetSpawner.Spawn(info);
			return true;
		}

		private static void OnItemSpawned(NetworkAssetSpawner.SpawnCallbackInfo info)
		{
			MessageRelay.RelayModule<GamemodeDropperMessage, GamemodeDropperData>(new GamemodeDropperData
			{
				Entity = new NetworkEntityReference(info.Entity.ID)
			}, CommonMessageRoutes.ReliableToClients);
		}

		public static bool DespawnItems()
		{
			if (!NetworkInfo.IsHost)
			{
				return false;
			}
			Poolee[] array = DroppedItems.ToArray();
			foreach (Poolee val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					val.Despawn();
				}
			}
			DroppedItems.Clear();
			return true;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class GamemodeDropperSettings : MonoBehaviour
	{
		[Serializable]
		public struct ItemDrop
		{
			public SpawnableCrateReference ItemCrateReference;

			public float Probability;
		}

		public static readonly List<ItemDrop> DefaultDrops = new List<ItemDrop>
		{
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-b59c-4790-9b09-499553776f72"),
				Probability = 20f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-a1c4-4c90-ad5d-ea1a53776f72"),
				Probability = 60f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-d3fc-4987-a93d-d79544616767"),
				Probability = 35f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("fa534c5a868247138f50c62e424c4144.Spawnable.Baton"),
				Probability = 45f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-6441-40aa-a070-909542617365"),
				Probability = 25f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-1f5a-4993-bbc1-03be4d656c65"),
				Probability = 19f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-6d15-47c7-9ad4-b04156696b69"),
				Probability = 50f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-282b-4430-b009-58954b617461"),
				Probability = 5f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-f6f9-4c96-b88e-91d74c656164"),
				Probability = 55f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-4774-460f-a814-149541786546"),
				Probability = 30f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("SLZ.BONELAB.Content.Spawnable.ElectricGuitar"),
				Probability = 41f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-02e7-43cf-bc8d-26955772656e"),
				Probability = 45f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-5d31-488d-b5b3-aa1c53686f76"),
				Probability = 30f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-d0e9-4d53-9218-e76446727969"),
				Probability = 50f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-0c8a-4b82-9f8b-7a9543726f77"),
				Probability = 55f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-1fb8-477c-afbe-2a95436f6d62"),
				Probability = 35f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-f0d1-40b6-9f9b-c19544616767"),
				Probability = 25f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-a97f-4bff-b512-e44d53706561"),
				Probability = 20f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-ec8e-418a-a545-cf955269666c"),
				Probability = 11f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("SLZ.BONELAB.CORE.Spawnable.GunEHG"),
				Probability = 15f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-2a4f-481f-8542-cc9545646572"),
				Probability = 22f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-a6b5-4177-beb8-04d947756e41"),
				Probability = 5f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("SLZ.BONELAB.Content.Spawnable.RifleM1Garand"),
				Probability = 18f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-e963-4a7c-8c7e-1195546f7942"),
				Probability = 50f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-c6a8-45d0-aaa2-2c954465764d"),
				Probability = 5f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-e777-4d15-b0c1-3195426f6172"),
				Probability = 20f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-cebf-42cc-be3a-4595506f7765"),
				Probability = 10f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-87ce-436d-b00c-ef9547726176"),
				Probability = 10f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("SLZ.BONELAB.Content.Spawnable.CardboardBoxHeadsetA"),
				Probability = 70f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("SLZ.BONELAB.Content.Spawnable.CardboardBoxHeadsetB"),
				Probability = 60f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-5be2-49d6-884e-d35c576f6f64"),
				Probability = 90f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-837c-43ca-b4b5-33d842617365"),
				Probability = 75f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-f938-40cb-8be5-23db41706f6c"),
				Probability = 70f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("SLZ.BONELAB.Content.Spawnable.ApolloGold"),
				Probability = 5f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("SLZ.BONELAB.Content.Spawnable.BlueApollo"),
				Probability = 30f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("SLZ.BONELAB.Content.Spawnable.Propbroom"),
				Probability = 75f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("SLZ.BONELAB.Content.Spawnable.BowlingBall"),
				Probability = 80f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-1e43-4d94-a504-31d457617465"),
				Probability = 88f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-6f93-4d58-b9a9-ca1c50726f70"),
				Probability = 73f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("SLZ.BONELAB.Content.Spawnable.Died20"),
				Probability = 60f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("SLZ.BONELAB.Content.Spawnable.ClayPotA"),
				Probability = 75f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("SLZ.BONELAB.Content.Spawnable.ClayVase"),
				Probability = 60f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-9629-4660-8439-186b50726f70"),
				Probability = 85f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("SLZ.BONELAB.Content.Spawnable.BowlingPin"),
				Probability = 80f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-3199-4102-91e2-8ac650726f70"),
				Probability = 45f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-202f-43f8-9a6c-1e9450726f70"),
				Probability = 5f
			},
			new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference("c1534c5a-ef15-44c0-88ae-aebc4e756c6c"),
				Probability = 11f
			}
		};

		public const int DefaultMaxItems = 5;

		public static GamemodeDropperSettings Instance { get; private set; } = null;


		[HideFromIl2Cpp]
		public List<ItemDrop> ItemDrops { get; private set; } = new List<ItemDrop>();


		[HideFromIl2Cpp]
		public int MaxItems { get; private set; } = 5;


		public GamemodeDropperSettings(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		public void AddItemDrop(string barcode, float probability)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			ItemDrops.Add(new ItemDrop
			{
				ItemCrateReference = new SpawnableCrateReference(barcode),
				Probability = probability
			});
		}

		public void SetMaxItems(int maxItems)
		{
			MaxItems = maxItems;
		}

		public static ItemDrop GetItemDrop()
		{
			if ((Object)(object)Instance != (Object)null && Instance.ItemDrops.Count > 0)
			{
				return GetItemDrop(Instance.ItemDrops);
			}
			return GetItemDrop(DefaultDrops);
		}

		private static ItemDrop GetItemDrop(List<ItemDrop> itemDrops)
		{
			float num = itemDrops.Sum((ItemDrop d) => d.Probability);
			float num2 = Random.Range(0f, num);
			foreach (ItemDrop itemDrop in itemDrops)
			{
				float probability = itemDrop.Probability;
				if (!(probability <= 0f))
				{
					num2 -= probability;
					if (num2 <= 0f)
					{
						return itemDrop;
					}
				}
			}
			return default(ItemDrop);
		}

		public static int GetMaxItems()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				return Instance.MaxItems;
			}
			return 5;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class GamemodeEvents : MonoBehaviour
	{
		public Il2CppReferenceField<UltEventHolder> onGamemodeStartedHolder;

		public Il2CppReferenceField<UltEventHolder> onGamemodeStoppedHolder;

		public GamemodeEvents(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			GamemodeManager.OnGamemodeStarted += OnGamemodeStarted;
			GamemodeManager.OnGamemodeStopped += OnGamemodeStopped;
			if (GamemodeManager.IsGamemodeStarted)
			{
				OnGamemodeStarted();
			}
		}

		private void OnDestroy()
		{
			GamemodeManager.OnGamemodeStarted -= OnGamemodeStarted;
			GamemodeManager.OnGamemodeStopped -= OnGamemodeStopped;
		}

		[HideFromIl2Cpp]
		private void OnGamemodeStarted()
		{
			UltEventHolder obj = onGamemodeStartedHolder.Get();
			if (obj != null)
			{
				obj.Invoke();
			}
		}

		[HideFromIl2Cpp]
		private void OnGamemodeStopped()
		{
			UltEventHolder obj = onGamemodeStoppedHolder.Get();
			if (obj != null)
			{
				obj.Invoke();
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public sealed class GamemodeMarker : MonoBehaviour
	{
		public static readonly HashSet<GamemodeMarker> Markers = new HashSet<GamemodeMarker>((IEqualityComparer<GamemodeMarker>?)new UnityComparer());

		private readonly HashSet<string> _teamBarcodes = new HashSet<string>();

		[HideFromIl2Cpp]
		public HashSet<string> TeamBarcodes => _teamBarcodes;

		public GamemodeMarker(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			Markers.Add(this);
		}

		private void OnDestroy()
		{
			Markers.Remove(this);
		}

		public void AddTeam(string barcode)
		{
			if (!string.IsNullOrWhiteSpace(barcode))
			{
				_teamBarcodes.Add(barcode);
			}
		}

		public void RemoveTeam(string barcode)
		{
			if (!string.IsNullOrWhiteSpace(barcode))
			{
				_teamBarcodes.Remove(barcode);
			}
		}

		public void ClearTeams()
		{
			_teamBarcodes.Clear();
		}

		public static IReadOnlyList<GamemodeMarker> FilterMarkers(BoneTagReference tag = null)
		{
			List<GamemodeMarker> list = new List<GamemodeMarker>();
			bool flag = tag != null;
			string text = (flag ? ((ScannableReference)tag).Barcode.ID : Barcode.EMPTY);
			foreach (GamemodeMarker marker in Markers)
			{
				bool flag2 = marker.TeamBarcodes != null && marker.TeamBarcodes.Count > 0;
				if (!flag && !flag2)
				{
					list.Add(marker);
					continue;
				}
				HashSet<string> teamBarcodes = marker.TeamBarcodes;
				bool flag3 = false;
				foreach (string item in teamBarcodes)
				{
					if (item == text)
					{
						flag3 = true;
						break;
					}
				}
				if (flag3)
				{
					list.Add(marker);
				}
			}
			return list;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class GamemodeMusicSettings : MonoBehaviour
	{
		private readonly Dictionary<string, string> _teamVictorySongOverrides = new Dictionary<string, string>();

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

		private readonly List<string> _songOverrides = new List<string>();

		private string _victorySongOverride;

		private string _failureSongOverride;

		private string _tieSongOverride;

		public static GamemodeMusicSettings Instance { get; set; }

		[HideFromIl2Cpp]
		public Dictionary<string, string> TeamVictorySongOverrides => _teamVictorySongOverrides;

		[HideFromIl2Cpp]
		public Dictionary<string, string> TeamFailureSongOverrides => _teamFailureSongOverrides;

		[HideFromIl2Cpp]
		public List<string> SongOverrides => _songOverrides;

		[HideFromIl2Cpp]
		public string VictorySongOverride => _victorySongOverride;

		[HideFromIl2Cpp]
		public string FailureSongOverride => _failureSongOverride;

		[HideFromIl2Cpp]
		public string TieSongOverride => _tieSongOverride;

		public GamemodeMusicSettings(IntPtr intPtr)
			: base(intPtr)
		{
		}

		[HideFromIl2Cpp]
		public void ApplyTeamOverrides(string barcode, ref MonoDiscReference victorySong, ref MonoDiscReference failureSong)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (TeamVictorySongOverrides.TryGetValue(barcode, out var value))
			{
				victorySong = new MonoDiscReference(value);
			}
			if (TeamFailureSongOverrides.TryGetValue(barcode, out var value2))
			{
				failureSong = new MonoDiscReference(value2);
			}
		}

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		public void SetVictorySong(string teamBarcode, string monoDiscBarcode)
		{
			_teamVictorySongOverrides[teamBarcode] = monoDiscBarcode;
		}

		public void SetVictorySong(string monoDiscBarcode)
		{
			_victorySongOverride = monoDiscBarcode;
		}

		public void SetFailureSong(string teamBarcode, string monoDiscBarcode)
		{
			_teamFailureSongOverrides[teamBarcode] = monoDiscBarcode;
		}

		public void SetFailureSong(string monoDiscBarcode)
		{
			_failureSongOverride = monoDiscBarcode;
		}

		public void SetTieSong(string monoDiscBarcode)
		{
			_tieSongOverride = monoDiscBarcode;
		}

		public void AddSong(string monoDiscBarcode)
		{
			_songOverrides.Add(monoDiscBarcode);
		}

		public void RemoveSong(string monoDiscBarcode)
		{
			_songOverrides.Remove(monoDiscBarcode);
		}

		public void ClearOverrides()
		{
			_teamVictorySongOverrides.Clear();
			_teamFailureSongOverrides.Clear();
			_songOverrides.Clear();
			_victorySongOverride = null;
			_failureSongOverride = null;
			_tieSongOverride = null;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class GamemodePlayerSettings : MonoBehaviour
	{
		private string _avatarOverride;

		private float? _vitalityOverride;

		public static GamemodePlayerSettings Instance { get; set; }

		[HideFromIl2Cpp]
		public string AvatarOverride => _avatarOverride;

		[HideFromIl2Cpp]
		public float? VitalityOverride => _vitalityOverride;

		public GamemodePlayerSettings(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		public void SetAvatar(string avatarBarcode)
		{
			_avatarOverride = avatarBarcode;
		}

		public void SetVitality(float vitality)
		{
			_vitalityOverride = vitality;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class GamemodeTeamSettings : MonoBehaviour
	{
		private readonly Dictionary<string, string> _teamNameOverrides = new Dictionary<string, string>();

		private readonly Dictionary<string, Texture2D> _teamLogoOverrides = new Dictionary<string, Texture2D>();

		public static GamemodeTeamSettings Instance { get; set; }

		[HideFromIl2Cpp]
		public Dictionary<string, string> TeamNameOverrides => _teamNameOverrides;

		[HideFromIl2Cpp]
		public Dictionary<string, Texture2D> TeamLogoOverrides => _teamLogoOverrides;

		public GamemodeTeamSettings(IntPtr intPtr)
			: base(intPtr)
		{
		}

		[HideFromIl2Cpp]
		public void ApplyOverrides(string barcode, ref string displayName, ref Texture logo)
		{
			if (TeamNameOverrides.TryGetValue(barcode, out var value))
			{
				displayName = value;
			}
			if (TeamLogoOverrides.TryGetValue(barcode, out var value2))
			{
				logo = (Texture)(object)value2;
			}
		}

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		public void SetTeamName(string barcode, string name)
		{
			_teamNameOverrides[barcode] = name;
		}

		public void SetTeamLogo(string barcode, Texture2D logo)
		{
			_teamLogoOverrides[barcode] = logo;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class RPCEvent : MonoBehaviour
	{
		public enum RPCRelayType
		{
			ToServer,
			ToClients,
			ToOtherClients
		}

		public enum RPCChannel
		{
			Reliable,
			Unreliable
		}

		public static readonly ComponentHashTable<RPCEvent> HashTable = new ComponentHashTable<RPCEvent>();

		public Il2CppValueField<int> relayType;

		public Il2CppValueField<int> channel;

		public Il2CppValueField<bool> requiresOwnership;

		public Il2CppReferenceField<UltEventHolder> onEventReceivedHolder;

		private int _relayTypeCached;

		private int _channelCached;

		private bool _requiresOwnershipCached;

		public RPCRelayType RelayType => (RPCRelayType)_relayTypeCached;

		public RPCChannel Channel => (RPCChannel)_channelCached;

		public bool RequiresOwnership => _requiresOwnershipCached;

		public RPCEvent(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			_relayTypeCached = relayType.Get();
			_channelCached = channel.Get();
			_requiresOwnershipCached = requiresOwnership.Get();
			int hierarchyHash = GameObjectHasher.GetHierarchyHash(((Component)this).gameObject);
			HashTable.AddComponent(hierarchyHash, this);
		}

		private void OnDestroy()
		{
			HashTable.RemoveComponent(this);
		}

		public void Receive()
		{
			UltEventHolder obj = onEventReceivedHolder.Get();
			if (obj != null)
			{
				obj.Invoke();
			}
		}

		public bool Invoke()
		{
			return RPCEventSender.Invoke(this);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class RPCVector3 : RPCVariable
	{
		private Vector3 _latestValue = Vector3.zero;

		public RPCVector3(IntPtr intPtr)
			: base(intPtr)
		{
		}//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)


		public Vector3 GetLatestValue()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _latestValue;
		}

		public bool SetValue(Vector3 value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return RPCVector3Sender.SetValue(this, value);
		}

		public void ReceiveValue(Vector3 value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_latestValue = value;
			InvokeHolder();
		}

		[HideFromIl2Cpp]
		public override void CatchupPlayer(PlayerID playerID)
		{
			RPCVector3Sender.CatchupValue(this, playerID);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class RPCString : RPCVariable
	{
		private string _latestValue = string.Empty;

		public RPCString(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public string GetLatestValue()
		{
			return _latestValue;
		}

		public bool SetValue(string value)
		{
			return RPCStringSender.SetValue(this, value);
		}

		public void ReceiveValue(string value)
		{
			_latestValue = value;
			InvokeHolder();
		}

		[HideFromIl2Cpp]
		public override void CatchupPlayer(PlayerID playerID)
		{
			RPCStringSender.CatchupValue(this, playerID);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class RPCBool : RPCVariable
	{
		private bool _latestValue;

		public RPCBool(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public bool GetLatestValue()
		{
			return _latestValue;
		}

		public bool SetValue(bool value)
		{
			return RPCBoolSender.SetValue(this, value);
		}

		public void ReceiveValue(bool value)
		{
			_latestValue = value;
			InvokeHolder();
		}

		[HideFromIl2Cpp]
		public override void CatchupPlayer(PlayerID playerID)
		{
			RPCBoolSender.CatchupValue(this, playerID);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class RPCFloat : RPCVariable
	{
		private float _latestValue;

		public RPCFloat(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public float GetLatestValue()
		{
			return _latestValue;
		}

		public bool SetValue(float value)
		{
			return RPCFloatSender.SetValue(this, value);
		}

		public void ReceiveValue(float value)
		{
			_latestValue = value;
			InvokeHolder();
		}

		[HideFromIl2Cpp]
		public override void CatchupPlayer(PlayerID playerID)
		{
			RPCFloatSender.CatchupValue(this, playerID);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class RPCInt : RPCVariable
	{
		private int _latestValue;

		public RPCInt(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public int GetLatestValue()
		{
			return _latestValue;
		}

		public bool SetValue(int value)
		{
			return RPCIntSender.SetValue(this, value);
		}

		public void ReceiveValue(int value)
		{
			_latestValue = value;
			InvokeHolder();
		}

		[HideFromIl2Cpp]
		public override void CatchupPlayer(PlayerID playerID)
		{
			RPCIntSender.CatchupValue(this, playerID);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class RPCVariable : MonoBehaviour
	{
		public static readonly ComponentHashTable<RPCVariable> HashTable = new ComponentHashTable<RPCVariable>();

		public Il2CppValueField<bool> requiresOwnership;

		public Il2CppReferenceField<UltEventHolder> onVariableChangedHolder;

		private bool _requiresOwnershipCached;

		public bool RequiresOwnership => _requiresOwnershipCached;

		public UltEventHolder OnVariableChangedHolder => onVariableChangedHolder.Get();

		[HideFromIl2Cpp]
		public bool HasNetworkEntity { get; set; }

		public RPCVariable(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			_requiresOwnershipCached = requiresOwnership.Get();
			int hierarchyHash = GameObjectHasher.GetHierarchyHash(((Component)this).gameObject);
			HashTable.AddComponent(hierarchyHash, this);
			CatchupManager.OnPlayerServerCatchup += OnPlayerServerCatchup;
		}

		[HideFromIl2Cpp]
		private void OnPlayerServerCatchup(PlayerID playerID)
		{
			if (!HasNetworkEntity)
			{
				CatchupPlayer(playerID);
			}
		}

		private void OnDestroy()
		{
			HashTable.RemoveComponent(this);
			CatchupManager.OnPlayerServerCatchup -= OnPlayerServerCatchup;
		}

		public void InvokeHolder()
		{
			try
			{
				UltEventHolder obj = OnVariableChangedHolder;
				if (obj != null)
				{
					obj.Invoke();
				}
			}
			catch
			{
			}
		}

		[HideFromIl2Cpp]
		public virtual void CatchupPlayer(PlayerID playerID)
		{
		}
	}
	[RegisterTypeInIl2Cpp]
	public class VoiceProxy : MonoBehaviour
	{
		public static readonly List<VoiceProxy> Proxies = new List<VoiceProxy>();

		public static readonly ComponentHashTable<VoiceProxy> HashTable = new ComponentHashTable<VoiceProxy>();

		private string _channel;

		private VoiceProxy _connectedProxy;

		private bool _canHearSelf;

		private int? _inputID;

		private VoiceSource _voiceSource;

		private VoiceProxy _listeningProxy;

		private bool _hasNetworkEntity;

		public string Channel
		{
			get
			{
				return _channel;
			}
			set
			{
				if (!(_channel == value))
				{
					_channel = value;
					ProcessVoiceProxies();
				}
			}
		}

		[HideFromIl2Cpp]
		public VoiceProxy ConnectedProxy
		{
			get
			{
				return _connectedProxy;
			}
			set
			{
				if (!((Object)(object)_connectedProxy == (Object)(object)value))
				{
					_connectedProxy = value;
					ProcessVoiceProxies();
				}
			}
		}

		public bool CanHearSelf
		{
			get
			{
				return _canHearSelf;
			}
			set
			{
				if (_canHearSelf != value)
				{
					_canHearSelf = value;
					if (!value && (Object)(object)VoiceSource != (Object)null && VoiceSource.ID == PlayerIDManager.LocalSmallID)
					{
						VoiceSource.ID = -1;
					}
				}
			}
		}

		public bool DistanceFalloff { get; set; }

		public float FalloffMinDistance { get; set; } = 0.2f;


		public float FalloffMaxDistance { get; set; } = 500f;


		[HideFromIl2Cpp]
		public int? InputID
		{
			get
			{
				return _inputID;
			}
			set
			{
				if (_inputID != value)
				{
					_inputID = value;
					ProcessVoiceProxies();
				}
			}
		}

		[HideFromIl2Cpp]
		public float InputVolume { get; set; } = 1f;


		[HideFromIl2Cpp]
		public VoiceSource VoiceSource => _voiceSource;

		[HideFromIl2Cpp]
		public VoiceProxy ListeningProxy => _listeningProxy;

		public bool Enabled { get; private set; }

		public bool HasNetworkEntity
		{
			get
			{
				return _hasNetworkEntity;
			}
			set
			{
				if (_hasNetworkEntity != value)
				{
					_hasNetworkEntity = value;
					ProcessVoiceProxies();
				}
			}
		}

		public VoiceProxy(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			HashTable.AddComponent(GameObjectHasher.GetHierarchyHash(((Component)this).gameObject), this);
			Proxies.Add(this);
			if (NetworkSceneManager.IsLevelNetworked)
			{
				_voiceSource = VoiceSourceManager.CreateVoiceSource(((Component)this).gameObject, -1);
				_voiceSource.OverrideFilter = true;
			}
		}

		private void OnDestroy()
		{
			HashTable.RemoveComponent(this);
			Proxies.RemoveAll((VoiceProxy p) => (Object)(object)p == (Object)(object)this);
		}

		private void OnEnable()
		{
			Enabled = true;
			InputVolume = 1f;
		}

		private void OnDisable()
		{
			Enabled = false;
			InputVolume = 1f;
		}

		private void LateUpdate()
		{
			InputVolume = CalculateInputFalloff();
		}

		private void OnAudioFilterRead(Il2CppStructArray<float> data, int channels)
		{
			if (!((Object)(object)VoiceSource == (Object)null) && VoiceSource.Playing)
			{
				AudioStreamFilter streamFilter = VoiceSource.StreamFilter;
				if ((Object)(object)ListeningProxy != (Object)null)
				{
					float inputVolume = ListeningProxy.InputVolume;
					streamFilter.SampleMultiplier = inputVolume * inputVolume;
				}
				else
				{
					streamFilter.SampleMultiplier = 1f;
				}
				streamFilter.ProcessAudioFilter(data, channels);
			}
		}

		private float CalculateInputFalloff()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (!DistanceFalloff)
			{
				return 1f;
			}
			if (!InputID.HasValue)
			{
				return 1f;
			}
			if (!NetworkPlayerManager.TryGetPlayer((byte)InputID.Value, out var player) || !player.HasRig)
			{
				return 1f;
			}
			Vector3 val = player.RigRefs.Mouth.position - ((Component)this).transform.position;
			float magnitude = ((Vector3)(ref val)).magnitude;
			return CalculateVolumeFalloff(magnitude);
		}

		private float CalculateVolumeFalloff(float distance)
		{
			if (!DistanceFalloff)
			{
				return 1f;
			}
			float num = System.Math.Max(0.05f, FalloffMinDistance);
			float num2 = System.Math.Max(num + 0.05f, FalloffMaxDistance);
			float num3 = System.Math.Max(num, distance);
			return (float)System.Math.Pow(num / num3, 500f / num2);
		}

		public void SetChannelString(string channel)
		{
			Channel = channel;
		}

		public void SetChannelInt32(int channel)
		{
			Channel = channel.ToString();
		}

		public void SetConnectedProxy(Object connectedProxy)
		{
			ConnectedProxy = ((Il2CppObjectBase)connectedProxy).TryCast<VoiceProxy>();
		}

		public void SetCanHearSelf(bool value)
		{
			CanHearSelf = value;
		}

		public void SetDistanceFalloff(bool enabled, float min, float max)
		{
			DistanceFalloff = enabled;
			FalloffMinDistance = min;
			FalloffMaxDistance = max;
		}

		public float GetOutputAmplitude()
		{
			if (!((Object)(object)VoiceSource != (Object)null))
			{
				return 0f;
			}
			return VoiceSource.Amplitude;
		}

		public bool IsOutputtingVoice()
		{
			if ((Object)(object)VoiceSource != (Object)null && VoiceSource.ID != -1)
			{
				return VoiceSource.ReceivingInput;
			}
			return false;
		}

		public void ToggleInput(bool input)
		{
			if (NetworkSceneManager.IsLevelNetworked)
			{
				SendInput(input, PlayerIDManager.LocalSmallID);
			}
		}

		[HideFromIl2Cpp]
		private ComponentPathData CreatePathData()
		{
			return ComponentPathData.CreateFromComponent<VoiceProxy, VoiceProxyExtender>(this, HashTable, VoiceProxyExtender.Cache);
		}

		[HideFromIl2Cpp]
		private void SendInput(bool input, byte playerID)
		{
			MessageRelay.RelayModule<VoiceProxyInputMessage, VoiceProxyInputData>(new VoiceProxyInputData
			{
				ComponentData = CreatePathData(),
				PlayerID = playerID,
				Input = input
			}, CommonMessageRoutes.ReliableToClients);
		}

		private static void ProcessVoiceProxies()
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return;
			}
			foreach (VoiceProxy proxy in Proxies)
			{
				try
				{
					proxy.ProcessVoiceProxy();
				}
				catch (Exception e)
				{
					FusionLogger.LogException("processing VoiceProxy", e);
				}
			}
		}

		private void ProcessVoiceProxy()
		{
			VoiceSource.ID = -1;
			_listeningProxy = null;
			if ((Object)(object)ConnectedProxy != (Object)null)
			{
				_listeningProxy = ConnectedProxy;
			}
			else if (!string.IsNullOrWhiteSpace(Channel))
			{
				_listeningProxy = Proxies.Find(ProxyChannelPredicate);
			}
			if ((Object)(object)ListeningProxy != (Object)null)
			{
				int num = ListeningProxy.InputID.GetValueOrDefault(-1);
				if (num == PlayerIDManager.LocalSmallID && !CanHearSelf)
				{
					num = -1;
				}
				VoiceSource.ID = num;
			}
		}

		[HideFromIl2Cpp]
		private bool ProxyChannelPredicate(VoiceProxy proxy)
		{
			if ((Object)(object)proxy == (Object)(object)this)
			{
				return false;
			}
			if (proxy.Channel != Channel)
			{
				return false;
			}
			if ((Object)(object)proxy.ConnectedProxy != (Object)null)
			{
				return false;
			}
			if (!proxy.HasNetworkEntity && !proxy.Enabled)
			{
				return false;
			}
			if (!proxy.InputID.HasValue)
			{
				return false;
			}
			return true;
		}
	}
}
namespace LabFusion.Marrow.Zones
{
	public static class SafeZoneCuller
	{
		public static void Cull(MarrowEntity entity, bool isInactive = true)
		{
			ZoneManagerPlugin.InactiveManager.Cull(entity._inactiveStatus, isInactive);
		}
	}
}
namespace LabFusion.Marrow.Serialization
{
	public class SerializedAttack : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 44;

		public Attack Attack;

		public SerializedAttack()
		{
		}

		public SerializedAttack(Attack attack)
		{
			Attack = attack;
		}

		public int? GetSize()
		{
			return 44;
		}

		public void Serialize(INetSerializer serializer)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			float value = 0f;
			AttackType value2 = (AttackType)64;
			Vector3 value3 = Vector3.zero;
			Vector3 value4 = Vector3.zero;
			Vector3 value5 = Vector3.zero;
			if (!serializer.IsReader)
			{
				value = Attack.damage;
				value2 = Attack.attackType;
				value3 = NetworkTransformManager.EncodePosition(Attack.origin);
				value4 = Attack.direction;
				value5 = Attack.normal;
			}
			serializer.SerializeValue(ref value);
			serializer.SerializeValue<AttackType>(ref value2);
			NetSerializerUnityExtensions.SerializeValue(serializer, ref value3);
			NetSerializerUnityExtensions.SerializeValue(serializer, ref value4);
			NetSerializerUnityExtensions.SerializeValue(serializer, ref value5);
			if (serializer.IsReader)
			{
				Attack = new Attack
				{
					damage = value,
					attackType = value2,
					origin = NetworkTransformManager.DecodePosition(value3),
					direction = value4,
					normal = value5,
					backFacing = false,
					collider = null,
					OrderInPool = 0,
					proxy = null
				};
			}
		}
	}
	public class SerializedController : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 16;

		public float IndexCurl;

		public float MiddleCurl;

		public float RingCurl;

		public float PinkyCurl;

		public float ThumbCurl;

		public float SolvedGrip;

		public float PrimaryAxis;

		public XRControllerType ControllerType;

		public bool PrimaryInteractionButton;

		public bool SecondaryInteractionButton;

		public Vector2 ThumbstickAxis;

		public const float PRECISION_MULTIPLIER = 255f;

		public int? GetSize()
		{
			return 16;
		}

		public SerializedController()
		{
		}

		public SerializedController(BaseController controller)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			IndexCurl = controller._processedIndex;
			MiddleCurl = controller._processedMiddle;
			RingCurl = controller._processedRing;
			PinkyCurl = controller._processedPinky;
			ThumbCurl = controller._processedThumb;
			SolvedGrip = controller._solvedGrip;
			PrimaryAxis = controller._primaryAxis;
			ControllerType = controller.Type;
			PrimaryInteractionButton = controller._primaryInteractionButton;
			SecondaryInteractionButton = controller._secondaryInteractionButton;
			ThumbstickAxis = controller._thumbstickAxis;
		}

		public void CopyTo(BaseController controller)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			controller._processedIndex = IndexCurl;
			controller._processedMiddle = MiddleCurl;
			controller._processedRing = RingCurl;
			controller._processedPinky = PinkyCurl;
			controller._processedThumb = ThumbCurl;
			controller._solvedGrip = ManagedMathf.Clamp(SolvedGrip, 0f, OpenController.grabThreshold - 0.01f);
			controller._primaryAxis = PrimaryAxis;
			controller.Type = ControllerType;
			bool up = controller._primaryInteractionButtonUp;
			bool down = controller._primaryInteractionButtonDown;
			SolveButtonPress(controller._primaryInteractionButton, PrimaryInteractionButton, ref up, ref down);
			controller._primaryInteractionButtonUp = up;
			controller._primaryInteractionButtonDown = down;
			controller._primaryInteractionButton = PrimaryInteractionButton;
			bool up2 = controller._secondaryInteractionButtonUp;
			bool down2 = controller._secondaryInteractionButtonDown;
			SolveButtonPress(controller._secondaryInteractionButton, SecondaryInteractionButton, ref up2, ref down2);
			controller._secondaryInteractionButtonUp = up2;
			controller._secondaryInteractionButtonDown = down2;
			controller._secondaryInteractionButton = SecondaryInteractionButton;
			controller._thumbstickAxis = Vector2.Lerp(controller._thumbstickAxis, ThumbstickAxis, NetworkTickManager.InterpolationTime);
			controller._lastTimeGrabbed = TimeReferences.TimeSinceStartup;
		}

		public static void SolveButtonPress(bool lastValue, bool newValue, ref bool up, ref bool down)
		{
			if (newValue)
			{
				up = false;
				if (!lastValue)
				{
					down = true;
				}
				else
				{
					down = false;
				}
			}
			else
			{
				down = false;
				if (lastValue)
				{
					up = true;
				}
				else
				{
					up = false;
				}
			}
		}

		public void Serialize(INetSerializer serializer)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			SerializeCompressedFloat(serializer, ref IndexCurl);
			SerializeCompressedFloat(serializer, ref MiddleCurl);
			SerializeCompressedFloat(serializer, ref RingCurl);
			SerializeCompressedFloat(serializer, ref PinkyCurl);
			SerializeCompressedFloat(serializer, ref ThumbCurl);
			SerializeCompressedFloat(serializer, ref SolvedGrip);
			SerializeCompressedFloat(serializer, ref PrimaryAxis);
			serializer.SerializeValue<XRControllerType>(ref ControllerType, Precision.OneByte);
			serializer.SerializeValue(ref PrimaryInteractionButton);
			serializer.SerializeValue(ref SecondaryInteractionButton);
			SerializedSmallVector2 value = null;
			if (!serializer.IsReader)
			{
				value = SerializedSmallVector2.Compress(ThumbstickAxis);
			}
			NetSerializerExtensions.SerializeValue(serializer, ref value);
			if (serializer.IsReader)
			{
				ThumbstickAxis = value.Expand();
			}
		}

		private static void SerializeCompressedFloat(INetSerializer serializer, ref float value)
		{
			byte value2 = 0;
			if (!serializer.IsReader)
			{
				value2 = (byte)(value * 255f);
			}
			serializer.SerializeValue(ref value2);
			if (serializer.IsReader)
			{
				value = (float)(int)value2 / 255f;
			}
		}
	}
	public struct SerializedSoftEllipse : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 16;

		public SoftEllipse Ellipse;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Ellipse.XRadius);
			serializer.SerializeValue(ref Ellipse.XBias);
			serializer.SerializeValue(ref Ellipse.ZRadius);
			serializer.SerializeValue(ref Ellipse.ZBias);
		}

		public static implicit operator SoftEllipse(SerializedSoftEllipse ellipse)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ellipse.Ellipse;
		}

		public static implicit operator SerializedSoftEllipse(SoftEllipse ellipse)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			SerializedSoftEllipse result = default(SerializedSoftEllipse);
			result.Ellipse = ellipse;
			return result;
		}
	}
	public sealed class SerializedSpawnData : LabFusion.Network.Serialization.INetSerializable
	{
		public string Barcode;

		public SerializedTransform SerializedTransform;

		public uint TrackerID;

		public bool SpawnEffect;

		public EntitySource SpawnSource;

		public int? GetSize()
		{
			return Barcode.GetSize() + 19 + 4 + 1 + 1;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref Barcode);
			NetSerializerExtensions.SerializeValue(serializer, ref SerializedTransform);
			serializer.SerializeValue(ref TrackerID);
			serializer.SerializeValue(ref SpawnEffect);
			serializer.SerializeValue(ref SpawnSource, Precision.OneByte);
		}
	}
}
namespace LabFusion.Marrow.Scene
{
	public abstract class LevelEventHandler
	{
		public static readonly List<LevelEventHandler> Handlers = new List<LevelEventHandler>();

		public virtual string LevelBarcode => null;

		public bool IsInLevel()
		{
			if (string.IsNullOrWhiteSpace(LevelBarcode))
			{
				return true;
			}
			return FusionSceneManager.Barcode == LevelBarcode;
		}

		protected virtual void OnLevelLoaded()
		{
		}

		protected virtual void OnPlayerCatchup(PlayerID playerID)
		{
		}

		private static void OnLevelLoadedCallback()
		{
			for (int i = 0; i < Handlers.Count; i++)
			{
				LevelEventHandler levelEventHandler = Handlers[i];
				if (levelEventHandler.IsInLevel())
				{
					levelEventHandler.OnLevelLoaded();
				}
			}
		}

		private static void OnPlayerCatchupCallback(PlayerID playerID)
		{
			for (int i = 0; i < Handlers.Count; i++)
			{
				LevelEventHandler levelEventHandler = Handlers[i];
				if (levelEventHandler.IsInLevel())
				{
					levelEventHandler.OnPlayerCatchup(playerID);
				}
			}
		}

		public static void OnInitializeMelon()
		{
			MultiplayerHooking.OnMainSceneInitialized += OnLevelLoadedCallback;
			CatchupManager.OnPlayerServerCatchup += OnPlayerCatchupCallback;
			LoadHandlers(FusionMod.FusionAssembly);
		}

		public static void LoadHandlers(Assembly assembly)
		{
			if (assembly == null)
			{
				throw new NullReferenceException("Can't register from a null assembly!");
			}
			AssemblyUtilities.LoadAllValid<LevelEventHandler>(assembly, RegisterHandler);
		}

		public static void RegisterHandler<T>() where T : NativeMessageHandler
		{
			RegisterHandler(typeof(T));
		}

		protected static void RegisterHandler(Type type)
		{
			LevelEventHandler item = Activator.CreateInstance(type) as LevelEventHandler;
			Handlers.Add(item);
		}
	}
}
namespace LabFusion.Marrow.Pool
{
	public static class LocalAssetSpawner
	{
		public static Spawnable CreateSpawnable(SpawnableCrateReference crateReference)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			return new Spawnable
			{
				crateRef = crateReference,
				policyData = null
			};
		}

		public static Spawnable CreateSpawnable(string barcode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			return new Spawnable
			{
				crateRef = new SpawnableCrateReference(barcode),
				policyData = null
			};
		}

		public static void Register(Spawnable spawnable)
		{
			AssetSpawner.Register(spawnable);
		}

		public static void Spawn(Spawnable spawnable, Vector3 position, Quaternion rotation, Action<Poolee> spawnCallback = null)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			Nullable<Vector3> val = new Nullable<Vector3>(Vector3.zero)
			{
				hasValue = false
			};
			Nullable<int> val2 = new Nullable<int>(0)
			{
				hasValue = false
			};
			UniTask<Poolee> val3 = AssetSpawner.SpawnAsync(spawnable, position, rotation, val, (Transform)null, false, val2, (Action<GameObject>)null, (Action<GameObject>)null, (Action<GameObject>)null);
			Awaiter<Poolee> awaiter = val3.GetAwaiter();
			Action action = delegate
			{
				Poolee result = awaiter.GetResult();
				if (!((Object)(object)result == (Object)null))
				{
					spawnCallback?.Invoke(result);
				}
			};
			awaiter.OnCompleted(Action.op_Implicit(action));
		}
	}
	public static class SpawnableBlacklist
	{
		public static readonly List<string> ClientSideBarcodes = new List<string>();

		public static bool IsClientSide(string barcode)
		{
			if (ClientSideBarcodes.Contains(barcode))
			{
				return true;
			}
			return false;
		}
	}
}
namespace LabFusion.Marrow.Patching
{
	[HarmonyPatch(typeof(Actuator))]
	public static class ActuatorPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("Awake")]
		public static void Awake(Actuator __instance)
		{
			EventActuator val = ((Il2CppObjectBase)__instance).TryCast<EventActuator>();
			if ((Object)(object)val != (Object)null)
			{
				EventActuatorPatches.Awake(val);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnDestroy")]
		public static void OnDestroy(Actuator __instance)
		{
			EventActuator val = ((Il2CppObjectBase)__instance).TryCast<EventActuator>();
			if ((Object)(object)val != (Object)null)
			{
				EventActuatorPatches.OnDestroy(val);
			}
		}
	}
	[HarmonyPatch(typeof(ButtonController))]
	public static class ButtonControllerPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("ReadSensor")]
		public static void ReadSensorPrefix(ButtonController __instance, double fixedTime, float lastSensorValue)
		{
			if (!NetworkInfo.HasServer)
			{
				return;
			}
			NetworkEntity networkEntity = ButtonControllerExtender.Cache.Get(__instance);
			if (networkEntity != null)
			{
				ButtonControllerExtender extender = networkEntity.GetExtender<ButtonControllerExtender>();
				if (networkEntity.IsOwner)
				{
					OnOwnedButtonUpdate(__instance, extender);
				}
				else
				{
					OnReceivedButtonUpdate(__instance, extender);
				}
			}
		}

		private static void OnOwnedButtonUpdate(ButtonController controller, ButtonControllerExtender extender)
		{
			if (extender.Charged != controller._charged)
			{
				MessageRelay.RelayModule<ButtonChargeMessage, ButtonChargeData>(ButtonChargeData.Create(PlayerIDManager.LocalSmallID, extender.NetworkEntity.ID, controller._charged), CommonMessageRoutes.ReliableToOtherClients);
				extender.Charged = controller._charged;
			}
		}

		private static void OnReceivedButtonUpdate(ButtonController controller, ButtonControllerExtender extender)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Invalid comparison between Unknown and I4
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			bool charged = extender.Charged;
			SoftJointLimit linearLimit = ((CircuitSocket)controller)._servo.joint.linearLimit;
			float limit = ((SoftJointLimit)(ref linearLimit)).limit;
			ConfigurableJoint joint = ((CircuitSocket)controller)._servo.joint;
			ButtonMode buttonMode = controller.buttonMode;
			if ((int)buttonMode > 1)
			{
				if ((int)buttonMode == 2)
				{
					joint.targetPosition = Vector3.right * ProcessToggleButton(controller, limit, charged);
				}
			}
			else
			{
				joint.targetPosition = Vector3.right * ProcessClickButton(limit, charged);
			}
		}

		private static float ProcessClickButton(float limit, bool charged)
		{
			if (charged)
			{
				return 0f - limit;
			}
			return limit;
		}

		private static float ProcessToggleButton(ButtonController controller, float limit, bool charged)
		{
			if (controller._charged != charged && controller._toggleCharged)
			{
				return 0f - limit;
			}
			return limit;
		}
	}
	[HarmonyPatch(typeof(EventActuator))]
	public static class EventActuatorPatches
	{
		public static readonly ComponentHashTable<EventActuator> HashTable = new ComponentHashTable<EventActuator>();

		public static bool IgnoreOverride { get; set; } = false;


		public static void Awake(EventActuator actuator)
		{
			int hierarchyHash = GameObjectHasher.GetHierarchyHash(((Component)actuator).gameObject);
			HashTable.AddComponent(hierarchyHash, actuator);
			OverrideEvent(actuator, actuator.InputRose, OnInputRose);
			OverrideEvent(actuator, actuator.InputFell, OnInputFell);
			OverrideEvent(actuator, actuator.InputRoseOneShot, OnInputRoseOneShot);
		}

		public static void OnDestroy(EventActuator actuator)
		{
			HashTable.RemoveComponent(actuator);
		}

		private static void OverrideEvent(EventActuator actuator, UltEvent<float> ultEvent, Action<EventActuator, float> replacement)
		{
			UltEvent<float> copiedEvent;
			if (((UltEventBase)ultEvent).HasCalls)
			{
				List<PersistentCall> persistentCallsList = ((UltEventBase)ultEvent).PersistentCallsList;
				UltEvent<float> obj = new UltEvent<float>();
				((UltEventBase)obj)._PersistentCalls = new List<PersistentCall>();
				copiedEvent = obj;
				Enumerator<PersistentCall> enumerator = persistentCallsList.GetEnumerator();
				while (enumerator.MoveNext())
				{
					PersistentCall current = enumerator.Current;
					((UltEventBase)copiedEvent).PersistentCallsList.Add(current);
				}
				((UltEventBase)ultEvent).Clear();
				ultEvent.DynamicCalls += Action<float>.op_Implicit((Action<float>)NewCall);
			}
			void NewCall(float parameter0)
			{
				if (!NetworkSceneManager.IsLevelNetworked || IgnoreOverride)
				{
					RunOriginal(parameter0);
				}
				else if (CheckOwnership(actuator))
				{
					replacement(actuator, parameter0);
				}
			}
			void RunOriginal(float parameter0)
			{
				copiedEvent.Invoke(parameter0);
			}
		}

		private static bool CheckOwnership(EventActuator actuator)
		{
			Circuit input = actuator.input;
			if ((Object)(object)input == (Object)null)
			{
				return NetworkSceneManager.IsLevelHost;
			}
			return CircuitHelper.GetNetworkEntity(input)?.IsOwner ?? NetworkSceneManager.IsLevelHost;
		}

		private static void OnInputRose(EventActuator actuator, float f)
		{
			OnSendEvent(actuator, EventActuatorType.ROSE, f);
		}

		private static void OnInputFell(EventActuator actuator, float f)
		{
			OnSendEvent(actuator, EventActuatorType.FELL, f);
		}

		private static void OnInputRoseOneShot(EventActuator actuator, float f)
		{
			OnSendEvent(actuator, EventActuatorType.ROSEONESHOT, f);
		}

		private static void OnSendEvent(EventActuator actuator, EventActuatorType type, float value)
		{
			ComponentHashData dataFromComponent = HashTable.GetDataFromComponent(actuator);
			if (dataFromComponent != null)
			{
				MessageRelay.RelayModule<EventActuatorMessage, EventActuatorData>(EventActuatorData.Create(PlayerIDManager.LocalSmallID, dataFromComponent, type, value), CommonMessageRoutes.ReliableToClients);
			}
		}
	}
	[HarmonyPatch(typeof(Gun))]
	public static class GunPatches
	{
		public static bool IgnorePatches { get; set; }

		[HarmonyPatch("OnTriggerGripAttached")]
		[HarmonyPostfix]
		public static void OnTriggerGripAttached(Gun __instance, Hand hand)
		{
			if (NetworkInfo.HasServer && !hand.manager.IsLocalPlayer())
			{
				__instance._ammoInventory = NetworkGunManager.NetworkAmmoInventory;
			}
		}

		[HarmonyPatch("Fire")]
		[HarmonyPrefix]
		public static bool Fire(Gun __instance)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Invalid comparison between Unknown and I4
			if (IgnorePatches)
			{
				return true;
			}
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			Grip triggerGrip = __instance.triggerGrip;
			if ((Object)(object)triggerGrip == (Object)null)
			{
				return true;
			}
			Hand hand = triggerGrip.GetHand();
			if ((Object)(object)hand == (Object)null)
			{
				return true;
			}
			RigManager manager = hand.manager;
			if (NetworkPlayerManager.HasExternalPlayer(manager) && (int)__instance.cartridgeState == 1)
			{
				return false;
			}
			if (((Health)((Il2CppObjectBase)manager.health).TryCast<Player_Health>()).deathIsImminent)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("OnFire")]
		[HarmonyPrefix]
		public static void OnFire(Gun __instance)
		{
			if (IgnorePatches || !NetworkInfo.HasServer)
			{
				return;
			}
			NetworkEntity networkEntity = GunExtender.Cache.Get(__instance);
			if (networkEntity == null)
			{
				return;
			}
			GunExtender extender = networkEntity.GetExtender<GunExtender>();
			try
			{
				if (Object.op_Implicit((Object)(object)__instance.triggerGrip) && Object.op_Implicit((Object)(object)__instance.triggerGrip.attachedHands.Find(Predicate<Hand>.op_Implicit((Func<Hand, bool>)((Hand h) => h.manager.IsLocalPlayer())))))
				{
					MessageRelay.RelayModule<GunShotMessage, GunShotData>(GunShotData.Create((byte)((__instance._magState != null) ? ((byte)__instance._magState.AmmoCount) : 0), networkEntity.ID, (byte)extender.GetIndex(__instance).Value), CommonMessageRoutes.ReliableToOtherClients);
				}
			}
			catch (Exception e)
			{
				FusionLogger.LogException("patching Gun.OnFire", e);
			}
		}
	}
	[HarmonyPatch(typeof(PuppetMaster))]
	public static class PuppetMasterPatches
	{
		public static bool IgnorePatches { get; set; }

		[HarmonyPrefix]
		[HarmonyPatch("Kill")]
		[HarmonyPatch(new Type[] { })]
		public static bool KillPrefix(PuppetMaster __instance)
		{
			return ValidateKill(__instance);
		}

		[HarmonyPrefix]
		[HarmonyPatch("Kill")]
		[HarmonyPatch(new Type[] { typeof(StateSettings) })]
		public static bool KillPrefix(PuppetMaster __instance, StateSettings stateSettings)
		{
			return ValidateKill(__instance);
		}

		[HarmonyPrefix]
		[HarmonyPatch("PostKill")]
		public static void PostKill(PuppetMaster __instance)
		{
			if (!IgnorePatches && NetworkSceneManager.IsLevelNetworked && PuppetMasterExtender.Cache.TryGet(__instance, out var value) && value.IsOwner)
			{
				MessageRelay.RelayModule<PuppetMasterKillMessage, NetworkEntityReference>(new NetworkEntityReference(value), CommonMessageRoutes.ReliableToOtherClients);
				PuppetMasterExtender.LastKilled = value;
			}
		}

		private static bool ValidateKill(PuppetMaster puppetMaster)
		{
			if (IgnorePatches)
			{
				return true;
			}
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if (!PuppetMasterExtender.Cache.TryGet(puppetMaster, out var value))
			{
				return true;
			}
			if (!value.IsOwner)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(SubBehaviourHealth))]
	public static class SubBehaviourHealthPatches
	{
		[HarmonyPatch("TakeDamage")]
		[HarmonyPrefix]
		public static bool TakeDamage(SubBehaviourHealth __instance, int m, Attack attack)
		{
			if (!NetworkInfo.HasServer)
			{
				return true;
			}
			if (PuppetMasterExtender.Cache.TryGet(((SubBehaviourBase)__instance).behaviour.puppetMaster, out var value) && !value.IsOwner)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(DamageVolume))]
	public static class DamageVolumePatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerEnter")]
		public static bool OnTriggerEnterPrefix(Collider other)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			Rigidbody attachedRigidbody = other.attachedRigidbody;
			if ((Object)(object)attachedRigidbody == (Object)null)
			{
				return true;
			}
			MarrowBody val = MarrowBody.Cache.Get(((Component)attachedRigidbody).gameObject);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			MarrowEntity entity = val.Entity;
			if (!IMarrowEntityExtender.Cache.TryGet(entity, out var value))
			{
				return true;
			}
			if (value.GetExtender<NetworkPlayer>() != null && !value.IsOwner)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(SceneStreamer))]
	public class SceneStreamerPatches
	{
		public static bool IgnorePatches { get; set; }

		[HarmonyPatch("Reload")]
		[HarmonyPrefix]
		public static bool Reload()
		{
			if (!IgnorePatches && NetworkInfo.HasServer && !NetworkInfo.IsHost)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("Load", new Type[]
		{
			typeof(Barcode),
			typeof(Barcode)
		})]
		[HarmonyPrefix]
		public static bool BarcodeLoad(Barcode levelBarcode, Barcode loadLevelBarcode = null)
		{
			if (!IgnorePatches && NetworkInfo.HasServer && !NetworkInfo.IsHost)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("Load", new Type[]
		{
			typeof(LevelCrateReference),
			typeof(LevelCrateReference)
		})]
		[HarmonyPrefix]
		public static bool CrateLoad(LevelCrateReference level, LevelCrateReference loadLevel)
		{
			if (!IgnorePatches && NetworkInfo.HasServer && !NetworkInfo.IsHost)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Hand))]
	public static class HandPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("UpdateHovering")]
		public static bool UpdateHoveringPrefix(Hand __instance)
		{
			if (!__instance.manager.IsLocalPlayer())
			{
				return true;
			}
			if (LocalControls.DisableInteraction)
			{
				__instance.HoveringReceiver = null;
				__instance.farHoveringReciever = null;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Health))]
	public static class HealthPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetAvatar")]
		public static void SetAvatarPostfix(Health __instance, Avatar avatar)
		{
			if (!NetworkInfo.HasServer)
			{
				return;
			}
			List<Renderer> list = new List<Renderer>();
			foreach (Renderer item in (Il2CppArrayBase<Renderer>)(object)__instance.Renderers)
			{
				if (!((Object)(object)item == (Object)null))
				{
					list.Add(item);
				}
			}
			__instance.Renderers = Il2CppReferenceArray<Renderer>.op_Implicit(list.ToArray());
		}
	}
	[HarmonyPatch(typeof(ForcePullGrip))]
	public static class ForcePullGripPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnFarHandHoverUpdate")]
		public static bool OnFarHandHoverUpdatePrefix(ForcePullGrip __instance, ref bool __state, Hand hand)
		{
			__state = __instance.pullCoroutine != null;
			if (NetworkSceneManager.IsLevelNetworked && NetworkPlayerManager.HasExternalPlayer(hand.manager))
			{
				return false;
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch("OnFarHandHoverUpdate")]
		public static void OnFarHandHoverUpdatePostfix(ForcePullGrip __instance, ref bool __state, Hand hand)
		{
			if (__instance.pullCoroutine != null && !__state)
			{
				GrabHelper.SendObjectForcePull(hand, __instance._grip);
			}
		}
	}
	[HarmonyPatch(typeof(InventoryAmmoReceiver))]
	public static class InventoryAmmoReceiverPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnHandGrab")]
		public static bool OnHandGrabPrefix(InventoryAmmoReceiver __instance, Hand hand)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if (!__instance._parentRigManager.IsLocalPlayer())
			{
				return true;
			}
			if (LocalControls.DisableAmmoPouch || LocalControls.DisableInteraction)
			{
				return false;
			}
			try
			{
				MagazineData selectedMagazineData = __instance._selectedMagazineData;
				if ((Object)(object)selectedMagazineData == (Object)null)
				{
					return false;
				}
				CartridgeData selectedCartridgeData = __instance._selectedCartridgeData;
				if ((Object)(object)selectedCartridgeData == (Object)null || AmmoInventory.Instance.GetCartridgeCount(selectedCartridgeData) <= 0)
				{
					return false;
				}
				Handedness handedness = hand.handedness;
				Transform transform = ((Component)__instance).transform;
				NetworkAssetSpawner.SpawnRequestInfo info2 = default(NetworkAssetSpawner.SpawnRequestInfo);
				info2.Spawnable = selectedMagazineData.spawnable;
				info2.Position = transform.position;
				info2.Rotation = transform.rotation;
				info2.SpawnCallback = delegate(NetworkAssetSpawner.SpawnCallbackInfo info)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					OnMagazineSpawned(info, handedness);
				};
				info2.SpawnSource = EntitySource.Player;
				NetworkAssetSpawner.Spawn(info2);
				return false;
			}
			catch (Exception e)
			{
				FusionLogger.LogException("patching InventoryAmmoReceiver.OnHandGrab", e);
			}
			return true;
		}

		private static void OnMagazineSpawned(NetworkAssetSpawner.SpawnCallbackInfo info, Handedness handedness)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Magazine component = info.Spawned.GetComponent<Magazine>();
			if (!((Object)(object)component == (Object)null))
			{
				NetworkPlayer networkPlayer = LocalPlayer.GetNetworkPlayer();
				if (networkPlayer != null)
				{
					MagazineUtilities.GrabMagazine(component, networkPlayer, handedness);
				}
				MessageRelay.RelayModule<MagazineClaimMessage, MagazineClaimData>(new MagazineClaimData
				{
					OwnerID = PlayerIDManager.LocalSmallID,
					EntityID = info.Entity.ID,
					Handedness = handedness
				}, CommonMessageRoutes.ReliableToOtherClients);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnHandDrop")]
		public static bool OnHandDropPrefix(InventoryAmmoReceiver __instance, IGrippable host)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if (!__instance._parentRigManager.IsLocalPlayer())
			{
				return true;
			}
			InteractableHost val = ((Il2CppObjectBase)host).TryCast<InteractableHost>();
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			if (!InteractableHostExtender.Cache.TryGet(val, out var value) || !value.IsRegistered)
			{
				return true;
			}
			MagazineExtender extender = value.GetExtender<MagazineExtender>();
			if (extender == null)
			{
				return true;
			}
			if (!((AlignPlug)extender.Component.magazinePlug)._isLocked)
			{
				NetworkAssetSpawner.DespawnRequestInfo info = default(NetworkAssetSpawner.DespawnRequestInfo);
				info.EntityID = value.ID;
				info.DespawnEffect = false;
				NetworkAssetSpawner.Despawn(info);
				MessageRelay.RelayModule<InventoryAmmoReceiverDropMessage, InventoryAmmoReceiverDropData>(new InventoryAmmoReceiverDropData
				{
					EntityID = (byte)PlayerIDManager.LocalID
				}, CommonMessageRoutes.ReliableToClients);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(InventorySlotReceiver))]
	public class InventorySlotReceiverPatches
	{
		public static bool IgnorePatches { get; set; }

		private static void OnDropWeapon(InventorySlotReceiver __instance, Hand hand = null)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (IgnorePatches || !NetworkSceneManager.IsLevelNetworked || !Object.op_Implicit((Object)(object)__instance._slottedWeapon) || !InventorySlotReceiverExtender.Cache.TryGet(__instance, out var value))
			{
				return;
			}
			byte? b = (byte?)value.GetExtender<InventorySlotReceiverExtender>().GetIndex(__instance);
			if (!b.HasValue)
			{
				return;
			}
			Handedness handedness = (Handedness)0;
			if ((Object)(object)hand != (Object)null)
			{
				handedness = hand.handedness;
				if (!value.IsOwner && AchievementManager.TryGetAchievement<HighwayMan>(out var achievement))
				{
					achievement.IncrementTask();
				}
			}
			MessageRelay.RelayModule<InventorySlotDropMessage, InventorySlotDropData>(new InventorySlotDropData
			{
				SlotEntityID = value.ID,
				GrabberID = PlayerIDManager.LocalSmallID,
				SlotIndex = b.Value,
				Handedness = handedness
			}, CommonMessageRoutes.ReliableToOtherClients);
		}

		[HarmonyPrefix]
		[HarmonyPatch("DropWeapon")]
		public static void DropWeaponPrefix(InventorySlotReceiver __instance)
		{
			OnDropWeapon(__instance);
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnHandGrab")]
		public static void OnHandGrabPrefix(InventorySlotReceiver __instance, Hand hand)
		{
			OnDropWeapon(__instance, hand);
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnHandDrop")]
		public static bool OnHandDropPrefix()
		{
			if (IgnorePatches)
			{
				return true;
			}
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if (LocalControls.DisableInteraction || LocalControls.DisableInventory)
			{
				return false;
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch("OnHandDrop")]
		public static void OnHandDropPostfix(InventorySlotReceiver __instance, IGrippable host)
		{
			if (IgnorePatches || !NetworkSceneManager.IsLevelNetworked || !Object.op_Implicit((Object)(object)__instance._slottedWeapon))
			{
				return;
			}
			NetworkEntity networkEntity = WeaponSlotExtender.Cache.Get(__instance._slottedWeapon);
			if (networkEntity != null && InventorySlotReceiverExtender.Cache.TryGet(__instance, out var value))
			{
				byte? b = (byte?)value.GetExtender<InventorySlotReceiverExtender>().GetIndex(__instance);
				if (b.HasValue)
				{
					MessageRelay.RelayModule<InventorySlotInsertMessage, InventorySlotInsertData>(new InventorySlotInsertData
					{
						SlotEntityID = value.ID,
						WeaponID = networkEntity.ID,
						SlotIndex = b.Value
					}, CommonMessageRoutes.ReliableToOtherClients);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SpawnInSlotAsync")]
		public static bool SpawnInSlotAsyncPrefix(InventorySlotReceiver __instance, Barcode barcode, ref UniTask<bool> __result)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			__result = new UniTask<bool>(false);
			FusionSceneManager.HookOnLevelLoad(delegate
			{
				SpawnInSlotAsyncOnLevelLoad(__instance, barcode);
			});
			return false;
		}

		private static void SpawnInSlotAsyncOnLevelLoad(InventorySlotReceiver slot, Barcode barcode)
		{
			if (!InventorySlotReceiverExtender.Cache.TryGet(slot, out var value) || !value.IsOwner)
			{
				return;
			}
			try
			{
				NetworkSpawnInSlotAsync(slot, barcode);
			}
			catch (Exception e)
			{
				FusionLogger.LogException("executing NetworkSpawnInSlotAsync", e);
			}
		}

		private static void NetworkSpawnInSlotAsync(InventorySlotReceiver slot, Barcode barcode)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			Spawnable spawnable = new Spawnable
			{
				crateRef = new SpawnableCrateReference(barcode),
				policyData = null
			};
			NetworkAssetSpawner.SpawnRequestInfo info2 = default(NetworkAssetSpawner.SpawnRequestInfo);
			info2.Spawnable = spawnable;
			info2.Position = ((Component)slot).transform.position;
			info2.Rotation = ((Component)slot).transform.rotation;
			info2.SpawnEffect = false;
			info2.SpawnCallback = delegate(NetworkAssetSpawner.SpawnCallbackInfo info)
			{
				WeaponSlotExtender extender = info.Entity.GetExtender<WeaponSlotExtender>();
				if (extender != null)
				{
					WeaponSlot component = extender.Component;
					if (!((Object)(object)component == (Object)null) && !((Object)(object)component.interactableHost == (Object)null))
					{
						((InventoryHandReceiver)slot).OnHandDrop(((Il2CppObjectBase)component.interactableHost).TryCast<IGrippable>());
					}
				}
			};
			NetworkAssetSpawner.Spawn(info2);
		}
	}
	[HarmonyPatch(typeof(ObjectCleanupVolume))]
	public static class ObjectCleanupVolumePatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerEnter")]
		public static void OnTriggerEnter(Collider col)
		{
			if (!NetworkInfo.HasServer)
			{
				return;
			}
			Rigidbody attachedRigidbody = col.attachedRigidbody;
			if ((Object)(object)attachedRigidbody == (Object)null)
			{
				return;
			}
			MarrowBody val = MarrowBody.Cache.Get(((Component)attachedRigidbody).gameObject);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			TriggerRefProxy component = ((Component)val).GetComponent<TriggerRefProxy>();
			if (!((Object)(object)component == (Object)null) && !((Object)(object)component.root == (Object)null))
			{
				RigManager val2 = RigManager.Cache.Get(component.root);
				if (!((Object)(object)val2 == (Object)null) && val2.IsLocalPlayer())
				{
					LocalPlayer.TeleportToCheckpoint();
				}
			}
		}
	}
	[HarmonyPatch(typeof(AlignPlug))]
	public static class AlignPlugPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnHandAttached")]
		public static bool OnHandAttached(AlignPlug __instance, InteractableHost host, Hand hand)
		{
			return ValidatePlug(__instance, hand);
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnHandDetached")]
		public static bool OnHandDetached(AlignPlug __instance, InteractableHost host, Hand hand)
		{
			return ValidatePlug(__instance, hand);
		}

		[HarmonyPatch("OnProxyGrab")]
		[HarmonyPrefix]
		public static bool OnProxyGrab(AlignPlug __instance, Hand hand)
		{
			return ValidatePlug(__instance, hand);
		}

		[HarmonyPatch("OnProxyRelease")]
		[HarmonyPrefix]
		public static bool OnProxyRelease(AlignPlug __instance, Hand hand)
		{
			return ValidatePlug(__instance, hand);
		}

		private static bool ValidatePlug(AlignPlug plug, Hand hand)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if ((Object)(object)((Il2CppObjectBase)plug).TryCast<AmmoPlug>() == (Object)null)
			{
				return true;
			}
			if (NetworkPlayerManager.HasExternalPlayer(hand.manager))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(AmmoPlug))]
	public static class AmmoPlugPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnPlugInsertComplete")]
		public static void OnPlugInsertCompletePrefix(AmmoPlug __instance)
		{
			if (NetworkSceneManager.IsLevelNetworked)
			{
				Socket lastSocket = ((AlignPlug)__instance)._lastSocket;
				if ((Object)(object)lastSocket != (Object)null && lastSocket.IsClearOnInsert)
				{
					PooleeDespawnPatch.IgnorePatch = true;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("OnPlugInsertComplete")]
		public static void OnPlugInsertCompletePostfix(AmmoPlug __instance)
		{
			if (NetworkSceneManager.IsLevelNetworked)
			{
				PooleeDespawnPatch.IgnorePatch = false;
			}
		}
	}
	[HarmonyPatch(typeof(AmmoSocket))]
	public static class AmmoSocketPatches
	{
		public static bool IgnorePatch { get; set; }

		[HarmonyPrefix]
		[HarmonyPatch("EjectMagazine")]
		public static bool EjectMagazine(AmmoSocket __instance)
		{
			if (IgnorePatch)
			{
				return true;
			}
			Gun gun = __instance.gun;
			if (NetworkSceneManager.IsLevelNetworked && (Object)(object)gun != (Object)null && (Object)(object)gun.triggerGrip != (Object)null)
			{
				Hand hand = gun.triggerGrip.GetHand();
				if ((Object)(object)hand != (Object)null && NetworkPlayerManager.HasExternalPlayer(hand.manager))
				{
					return false;
				}
			}
			return true;
		}

		[HarmonyPatch("OnPlugLocked")]
		[HarmonyPrefix]
		public static void OnPlugLocked(AmmoSocket __instance, Plug plug)
		{
			if (IgnorePatch || !NetworkSceneManager.IsLevelNetworked || !Object.op_Implicit((Object)(object)__instance.gun))
			{
				return;
			}
			NetworkEntity networkEntity = GunExtender.Cache.Get(__instance.gun);
			if (networkEntity == null)
			{
				return;
			}
			AmmoPlug val = ((Il2CppObjectBase)plug).TryCast<AmmoPlug>();
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.magazine == (Object)null))
			{
				NetworkEntity networkEntity2 = MagazineExtender.Cache.Get(val.magazine);
				if (networkEntity2 != null)
				{
					MessageRelay.RelayModule<MagazineInsertMessage, MagazineInsertData>(new MagazineInsertData
					{
						MagazineID = networkEntity2.ID,
						GunID = networkEntity.ID
					}, CommonMessageRoutes.ReliableToOtherClients);
				}
			}
		}

		[HarmonyPatch("OnPlugUnlocked")]
		[HarmonyPrefix]
		public static void OnPlugUnlocked(AmmoSocket __instance)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			if (IgnorePatch || !NetworkSceneManager.IsLevelNetworked || !Object.op_Implicit((Object)(object)__instance.gun) || ((Socket)__instance).IsClearOnInsert)
			{
				return;
			}
			NetworkEntity networkEntity = GunExtender.Cache.Get(__instance.gun);
			if (networkEntity == null)
			{
				return;
			}
			AmmoPlug magazinePlug = __instance._magazinePlug;
			if (Object.op_Implicit((Object)(object)magazinePlug) && Object.op_Implicit((Object)(object)magazinePlug.magazine))
			{
				NetworkEntity networkEntity2 = MagazineExtender.Cache.Get(magazinePlug.magazine);
				if (networkEntity2 != null)
				{
					Hand hand = ((Plug)magazinePlug).host.GetHand(0);
					Handedness handedness = (Handedness)(((Object)(object)hand != (Object)null) ? ((int)hand.handedness) : 0);
					MessageRelay.RelayModule<MagazineEjectMessage, MagazineEjectData>(new MagazineEjectData
					{
						PlayerID = PlayerIDManager.LocalSmallID,
						MagazineID = networkEntity2.ID,
						GunID = networkEntity.ID,
						Handedness = handedness
					}, CommonMessageRoutes.ReliableToOtherClients);
				}
			}
		}
	}
	public struct ConstrainerPointPair
	{
		public ConstraintMode mode;

		public Vector3 point1;

		public Vector3 point2;

		public Vector3 normal1;

		public Vector3 normal2;

		public GameObject go1;

		public GameObject go2;

		public ConstrainerPointPair(Constrainer constrainer)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			mode = constrainer.mode;
			point1 = constrainer._point1;
			point2 = constrainer._point2;
			normal1 = constrainer._normal1;
			normal2 = constrainer._normal2;
			go1 = (Object.op_Implicit((Object)(object)constrainer._mb1) ? ((Component)constrainer._mb1).gameObject : constrainer._gO1);
			go2 = (Object.op_Implicit((Object)(object)constrainer._mb2) ? ((Component)constrainer._mb2).gameObject : constrainer._gO2);
		}
	}
	[HarmonyPatch(typeof(Constrainer))]
	public static class ConstrainerPatches
	{
		public static bool IsReceivingConstraints { get; set; }

		public static ushort FirstId { get; set; }

		public static ushort SecondId { get; set; }

		private static bool IsPlayer(MarrowBody body)
		{
			if ((Object)(object)body == (Object)null)
			{
				return false;
			}
			if (!MarrowBodyExtender.Cache.TryGet(body, out var value))
			{
				return false;
			}
			return value.GetExtender<NetworkPlayer>() != null;
		}

		[HarmonyPrefix]
		[HarmonyPatch("PrimaryButtonUp")]
		public static bool PrimaryButtonUpPrefix(Constrainer __instance)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			if (IsReceivingConstraints)
			{
				return true;
			}
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if ((int)__instance.mode == 6)
			{
				return true;
			}
			if (!ConstrainerUtilities.PlayerConstraintsEnabled)
			{
				bool flag = false;
				if (IsPlayer(__instance._mb1))
				{
					__instance._gO1 = null;
					__instance._mb1 = null;
					flag = true;
				}
				if (IsPlayer(__instance._mb2))
				{
					__instance._gO2 = null;
					__instance._mb2 = null;
					flag = true;
				}
				if (flag)
				{
					__instance._raycastMissedOnDown = true;
					__instance.sfx.Release();
					return false;
				}
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch("PrimaryButtonUp")]
		public static void PrimaryButtonUpPostfix(Constrainer __instance)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return;
			}
			GameObject gO = __instance._gO1;
			GameObject gO2 = __instance._gO2;
			if ((int)__instance.mode == 6 || !Object.op_Implicit((Object)(object)gO) || !Object.op_Implicit((Object)(object)gO2) || (Object)(object)gO == (Object)(object)gO2)
			{
				return;
			}
			ConstraintTracker val = ((IEnumerable<ConstraintTracker>)__instance._gO1.GetComponents<ConstraintTracker>()).LastOrDefault();
			if (!((Object)(object)val == (Object)null))
			{
				ConstraintTracker otherTracker = val.otherTracker;
				if (!IsReceivingConstraints && ConstrainerExtender.Cache.TryGet(__instance, out var value))
				{
					ConstraintTrackerPatches.IgnorePatches = true;
					val.DeleteConstraint();
					ConstraintTrackerPatches.IgnorePatches = false;
					MessageRelay.RelayModule<ConstraintCreateMessage, ConstraintCreateData>(ConstraintCreateData.Create(PlayerIDManager.LocalSmallID, value.ID, new ConstrainerPointPair(__instance)), CommonMessageRoutes.ReliableToServer);
					return;
				}
				ConstrainerPointPair pointPair = new ConstrainerPointPair(__instance);
				NetworkEntity networkEntity = new NetworkEntity();
				new NetworkConstraint(networkEntity, val)
				{
					PointPair = pointPair,
					IsFirst = true,
					OtherId = SecondId
				};
				NetworkEntityManager.IDManager.RegisterEntity(FirstId, networkEntity);
				NetworkEntity networkEntity2 = new NetworkEntity();
				new NetworkConstraint(networkEntity2, otherTracker).PointPair = pointPair;
				NetworkEntityManager.IDManager.RegisterEntity(SecondId, networkEntity2);
				CatchupManager.RequestEntityDataCatchup(new NetworkEntityReference(networkEntity));
				CatchupManager.RequestEntityDataCatchup(new NetworkEntityReference(networkEntity2));
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerGripUpdate")]
		public static bool OnTriggerGripUpdatePrefix(Constrainer __instance, Hand hand)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if (NetworkPlayerManager.HasExternalPlayer(hand.manager))
			{
				return false;
			}
			NetworkEntity networkEntity = ConstrainerExtender.Cache.Get(__instance);
			if (networkEntity == null)
			{
				return true;
			}
			if (hand.Controller.GetMenuTap())
			{
				ConstraintMode mode = __instance.mode;
				mode = (ConstraintMode)(((int)mode != 6) ? (mode + 1) : ((ConstraintMode)0));
				MessageRelay.RelayModule<ConstrainerModeMessage, ConstrainerModeData>(new ConstrainerModeData
				{
					ConstrainerID = networkEntity.ID,
					Mode = mode
				}, CommonMessageRoutes.ReliableToOtherClients);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ConstraintTracker))]
	public static class ConstraintTrackerPatches
	{
		public static bool IgnorePatches { get; set; }

		[HarmonyPrefix]
		[HarmonyPatch("DeleteConstraint")]
		public static bool DeleteConstraint(ConstraintTracker __instance)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if (IgnorePatches || !((Behaviour)__instance).isActiveAndEnabled)
			{
				return true;
			}
			NetworkEntity networkEntity = NetworkConstraint.Cache.Get(__instance);
			if (networkEntity == null)
			{
				return true;
			}
			MessageRelay.RelayModule<ConstraintDeleteMessage, ConstraintDeleteData>(new ConstraintDeleteData
			{
				ConstraintID = networkEntity.ID
			}, CommonMessageRoutes.ReliableToClients);
			return false;
		}
	}
	[HarmonyPatch(typeof(FlyingGun))]
	public static class FlyingGunPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerGripUpdate")]
		public static bool OnTriggerGripUpdatePrefix(FlyingGun __instance, Hand hand, ref bool __state)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			if (FusionDevTools.DevToolsDisabled)
			{
				return false;
			}
			if (NetworkSceneManager.IsLevelNetworked && (int)hand.handedness == 1)
			{
				Hand otherHand = hand.otherHand;
				if (Object.op_Implicit((Object)(object)otherHand.m_CurrentAttachedGO))
				{
					Grip val = Grip.Cache.Get(otherHand.m_CurrentAttachedGO);
					if (((HandReciever)val).HasHost && (Object)(object)((HandReciever)val).Host.GetHostGameObject().GetComponent<FlyingGun>() != (Object)null)
					{
						return false;
					}
				}
			}
			__state = __instance._noClipping;
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch("OnTriggerGripUpdate")]
		public static void OnTriggerGripUpdatePostfix(FlyingGun __instance, Hand hand, bool __state)
		{
			if (NetworkSceneManager.IsLevelNetworked && hand.manager.IsLocalPlayer() && __state != __instance._noClipping)
			{
				NetworkEntity networkEntity = FlyingGunExtender.Cache.Get(__instance);
				if (networkEntity != null)
				{
					MessageRelay.RelayModule<NimbusGunNoClipMessage, NimbusGunNoClipData>(new NimbusGunNoClipData
					{
						NimbusGunID = networkEntity.ID,
						NoClip = __instance._noClipping
					}, CommonMessageRoutes.ReliableToOtherClients);
				}
			}
		}
	}
	[HarmonyPatch(typeof(GunManager))]
	public static class GunManagerPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnGunGrabbed")]
		public static void OnGunGrabbed(Hand hand, Gun gun)
		{
			if (NetworkInfo.HasServer && NetworkPlayerManager.TryGetPlayer(hand.manager, out var player) && !player.NetworkEntity.IsOwner)
			{
				OnNetworkGrab(player, gun);
			}
		}

		private static void OnNetworkGrab(NetworkPlayer player, Gun gun)
		{
			InventoryAmmoReceiverExtender extender = player.NetworkEntity.GetExtender<InventoryAmmoReceiverExtender>();
			if (extender != null)
			{
				extender.Component.SwitchMagazine(gun.defaultMagazine, gun.defaultCartridge);
			}
		}
	}
	public static class ImpactAttackValidator
	{
		public static bool ValidateImpact(GameObject weaponObject, InteractableHost weaponHost, ImpactProperties hitObject)
		{
			PhysicsRig componentInParent = ((Component)hitObject).GetComponentInParent<PhysicsRig>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return true;
			}
			Enumerator<Hand> enumerator = weaponHost._hands.GetEnumerator();
			while (enumerator.MoveNext())
			{
				if ((Object)(object)enumerator.Current.manager != (Object)(object)((Rig)componentInParent).manager)
				{
					return true;
				}
			}
			TriggerRefProxy lastGrabbedProxy = weaponHost.LastGrabbedProxy;
			if ((Object)(object)lastGrabbedProxy != (Object)null)
			{
				return !((Object)(object)RigManager.Cache.Get(lastGrabbedProxy.root) == (Object)(object)((Rig)componentInParent).manager);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(ImpactProperties))]
	public static class ImpactPropertiesPatches
	{
		[HarmonyPatch("ReceiveAttack")]
		[HarmonyPrefix]
		public static void ReceiveAttack(Attack attack)
		{
			if (NetworkSceneManager.IsLevelNetworked)
			{
				OnProcessAttack(attack);
			}
		}

		private static void OnProcessAttack(Attack attack)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			Collider collider = attack.collider;
			if ((Object)(object)attack.proxy == (Object)(object)RigData.Refs.Proxy && (int)attack.attackType == 1)
			{
				Rigidbody attachedRigidbody = collider.attachedRigidbody;
				if ((Object)(object)attachedRigidbody != (Object)null)
				{
					ImpactUtilities.OnHitRigidbody(attachedRigidbody);
				}
			}
		}
	}
	[HarmonyPatch(typeof(ImpactSFX))]
	public static class ImpactSFXPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("ImpactSound")]
		public static bool ImpactSound(ImpactSFX __instance, Collision c)
		{
			if (!NetworkInfo.HasServer)
			{
				return true;
			}
			if ((Object)(object)__instance._host == (Object)null)
			{
				return true;
			}
			ImpactProperties val = ImpactProperties.Cache.Get(c.gameObject);
			if (Object.op_Implicit((Object)(object)val))
			{
				return ImpactAttackValidator.ValidateImpact(((Component)__instance).gameObject, __instance._host, val);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(MarrowEntity))]
	public static class MarrowEntityPatches
	{
		public static readonly ComponentHashTable<MarrowEntity> HashTable = new ComponentHashTable<MarrowEntity>();

		private static bool IsPooled(MarrowEntity entity)
		{
			Poolee poolee = entity._poolee;
			if ((Object)(object)poolee == (Object)null)
			{
				return false;
			}
			if (!poolee.IsInPool)
			{
				return false;
			}
			return true;
		}

		private static bool IsRuntimeCreated(MarrowEntity entity)
		{
			if (Object.op_Implicit((Object)(object)((Component)entity).GetComponentInParent<Avatar>()))
			{
				return true;
			}
			if (Object.op_Implicit((Object)(object)((Component)entity).GetComponentInParent<AntiHasher>()))
			{
				return true;
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch("Awake")]
		public static void Awake(MarrowEntity __instance)
		{
			if (!IsPooled(__instance) && !IsRuntimeCreated(__instance))
			{
				int hierarchyHash = GameObjectHasher.GetHierarchyHash(((Component)__instance).gameObject);
				HashTable.AddComponent(hierarchyHash, __instance);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnDestroy")]
		public static void OnDestroy(MarrowEntity __instance)
		{
			HashTable.RemoveComponent(__instance);
		}

		[HarmonyPostfix]
		[HarmonyPatch("OnCullResolve")]
		public static void OnCullResolve(MarrowEntity __instance, InactiveStatus status, bool isInactive)
		{
			if (NetworkSceneManager.IsLevelNetworked)
			{
				IMarrowEntityExtender.Cache.Get(__instance)?.GetExtender<IMarrowEntityExtender>().OnEntityCull(isInactive);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("Despawn")]
		public static bool Despawn(MarrowEntity __instance)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if (IMarrowEntityExtender.Cache.TryGet(__instance, out var value) && value.GetExtender<NetworkPlayer>() != null)
			{
				FusionLogger.Warn($"Prevented MarrowEntity.Despawn of player at ID {value.ID}!");
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ObjectDestructible))]
	public static class ObjectDestructiblePatches
	{
		public class ObjectDestructibleState
		{
			public bool isDead;

			public LootTableData lootTable;

			public Vector3 spawnPosition;

			public Quaternion spawnRotation;

			public bool ignoringPatch;

			public ObjectDestructibleState(ObjectDestructible destructible)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				lootTable = destructible.lootTable;
				isDead = destructible._isDead;
				Transform val = destructible.spawnTarget ?? ((Component)destructible).transform;
				spawnPosition = val.position;
				spawnRotation = val.rotation;
			}
		}

		public static bool IgnorePatches { get; set; }

		[HarmonyPrefix]
		[HarmonyPatch("Awake")]
		public static void Awake(ObjectDestructible __instance)
		{
			UnityAction val = UnityAction.op_Implicit((Action)OnDestruct);
			__instance.OnDestruct.AddListener(val);
			void OnDestruct()
			{
				OnDestruction(__instance);
			}
		}

		private static void OnDestruction(ObjectDestructible destructible)
		{
			if (!NetworkInfo.HasServer)
			{
				return;
			}
			NetworkEntity networkEntity = ObjectDestructibleExtender.Cache.Get(destructible);
			if (networkEntity != null)
			{
				ObjectDestructibleExtender extender = networkEntity.GetExtender<ObjectDestructibleExtender>();
				if (networkEntity.IsOwner)
				{
					MessageRelay.RelayModule<ObjectDestructibleDestroyMessage, ComponentIndexData>(ComponentIndexData.Create(networkEntity.ID, extender.GetIndex(destructible).Value), CommonMessageRoutes.ReliableToOtherClients);
				}
			}
		}

		[HarmonyPatch("TakeDamage")]
		[HarmonyPrefix]
		public static bool TakeDamagePrefix(ObjectDestructible __instance, Vector3 normal, float damage, bool crit, AttackType attackType, ref ObjectDestructibleState __state)
		{
			__state = new ObjectDestructibleState(__instance);
			if (!NetworkInfo.HasServer)
			{
				return true;
			}
			__instance.lootTable = null;
			if (IgnorePatches)
			{
				return true;
			}
			if (ObjectDestructibleExtender.Cache.TryGet(__instance, out var value) && !value.IsOwner)
			{
				__state.ignoringPatch = true;
				return false;
			}
			return true;
		}

		[HarmonyPatch("TakeDamage")]
		[HarmonyPostfix]
		public static void TakeDamagePostfix(ObjectDestructible __instance, Vector3 normal, float damage, bool crit, AttackType attackType, ref ObjectDestructibleState __state)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkInfo.HasServer)
			{
				return;
			}
			__instance.lootTable = __state.lootTable;
			if (!IgnorePatches && !__state.ignoringPatch && __instance._isDead && !__state.isDead && (Object)(object)__instance.lootTable != (Object)null)
			{
				Spawnable spawnable = __instance.lootTable.GetLootItem();
				NetworkAssetSpawner.SpawnRequestInfo info2 = default(NetworkAssetSpawner.SpawnRequestInfo);
				info2.Spawnable = spawnable;
				info2.Position = __state.spawnPosition;
				info2.Rotation = __state.spawnRotation;
				info2.SpawnCallback = delegate(NetworkAssetSpawner.SpawnCallbackInfo info)
				{
					((UnityEvent<ObjectDestructible, Spawnable, GameObject>)(object)__instance.OnLootSpawn)?.Invoke(__instance, spawnable, info.Spawned);
				};
				NetworkAssetSpawner.Spawn(info2);
			}
		}
	}
	[HarmonyPatch(typeof(StabSlash))]
	public static class StabSlashPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("ProcessCollision")]
		public static bool ProcessCollision(StabSlash __instance, Collision c, bool isEnter = true)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if ((Object)(object)c.rigidbody != (Object)null && (Object)(object)MarrowBody.Cache.Get(((Component)c.rigidbody).gameObject) == (Object)null)
			{
				c.m_Body = null;
			}
			InteractableHost host = __instance._host;
			if ((Object)(object)host == (Object)null)
			{
				return true;
			}
			ImpactProperties val = ImpactProperties.Cache.Get(c.gameObject);
			if (Object.op_Implicit((Object)(object)val))
			{
				return ImpactAttackValidator.ValidateImpact(((Component)__instance).gameObject, host, val);
			}
			return true;
		}
	}
	public static class CrateSpawnerAndroidPatches
	{
		public static void PatchAll()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			MethodInfo method = typeof(_SpawnSpawnableAsync_d__26).GetMethod("MoveNext", AccessTools.all);
			HarmonyMethod val = new HarmonyMethod(typeof(CrateSpawnerAndroidPatches).GetMethod("MoveNextPrefix", AccessTools.all));
			((MelonBase)FusionMod.Instance).HarmonyInstance.Patch((MethodBase)method, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static bool MoveNextPrefix(_SpawnSpawnableAsync_d__26 __instance)
		{
			CrateSpawner _4__this = __instance.__4__this;
			Awaiter<Poolee> _u__ = __instance.__u__1;
			UniTask<Poolee> __result = _u__.task;
			bool num = CrateSpawnerPatches.SpawnSpawnableAsyncPrefix(_4__this, isHidden: false, ref __result);
			if (!num)
			{
				_u__.task = __result;
			}
			return num;
		}
	}
	[HarmonyPatch(typeof(CrateSpawner))]
	public static class CrateSpawnerPatches
	{
		public static readonly ComponentHashTable<CrateSpawner> HashTable = new ComponentHashTable<CrateSpawner>();

		public static void PatchAll()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			MethodInfo method = typeof(CrateSpawner).GetMethod("SpawnSpawnableAsync", AccessTools.all);
			HarmonyMethod val = new HarmonyMethod(typeof(CrateSpawnerPatches).GetMethod("SpawnSpawnableAsyncPrefix", AccessTools.all));
			((MelonBase)FusionMod.Instance).HarmonyInstance.Patch((MethodBase)method, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		[HarmonyPrefix]
		[HarmonyPatch("Awake")]
		public static void Awake(CrateSpawner __instance)
		{
			int hierarchyHash = GameObjectHasher.GetHierarchyHash(((Component)__instance).gameObject);
			HashTable.AddComponent(hierarchyHash, __instance);
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnDestroy")]
		public static void OnDestroy(CrateSpawner __instance)
		{
			HashTable.RemoveComponent(__instance);
		}

		private static void NetworkedSpawnSpawnable(CrateSpawner spawner, UniTaskCompletionSource<Poolee> source)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			Spawnable spawnable = spawner._spawnable;
			if (spawnable != null && ((ScannableReference)spawnable.crateRef).IsValid())
			{
				Transform transform = ((Component)spawner).transform;
				NetworkAssetSpawner.SpawnRequestInfo info2 = default(NetworkAssetSpawner.SpawnRequestInfo);
				info2.Spawnable = spawnable;
				info2.Position = transform.position;
				info2.Rotation = transform.rotation;
				info2.SpawnCallback = delegate(NetworkAssetSpawner.SpawnCallbackInfo info)
				{
					OnNetworkSpawn(spawner, info, source);
				};
				info2.SpawnSource = EntitySource.Scene;
				NetworkAssetSpawner.Spawn(info2);
			}
		}

		private static void OnNetworkSpawn(CrateSpawner spawner, NetworkAssetSpawner.SpawnCallbackInfo info, UniTaskCompletionSource<Poolee> source)
		{
			if (!((Object)(object)spawner == (Object)null))
			{
				GameObject spawned = info.Spawned;
				Poolee val = Poolee.Cache.Get(spawned);
				source.TrySetResult(val);
				if (info.Entity == null)
				{
					spawner.OnFinishNetworkSpawn(info.Spawned);
					return;
				}
				ushort iD = info.Entity.ID;
				CrateSpawnerMessage.SendCrateSpawnerMessage(spawner, iD);
			}
		}

		public static void OnFinishNetworkSpawn(this CrateSpawner spawner, GameObject go)
		{
			Poolee val = Poolee.Cache.Get(go);
			try
			{
				spawner.OnPooleeSpawn(go);
			}
			catch (Exception e)
			{
				FusionLogger.LogException("executing CrateSpawner.OnPooleeSpawn", e);
			}
			val.OnDespawnDelegate += Action<GameObject>.op_Implicit((Action<GameObject>)spawner.OnPooleeDespawn);
			try
			{
				((UltEvent<CrateSpawner, GameObject>)(object)spawner.onSpawnEvent)?.Invoke(spawner, go);
			}
			catch (Exception e2)
			{
				FusionLogger.LogException("executing CrateSpawner.onSpawnEvent", e2);
			}
		}

		private static bool IsSingleplayerOnly(CrateSpawner crateSpawner)
		{
			if (Desyncer.Cache.ContainsSource(((Component)crateSpawner).gameObject))
			{
				return true;
			}
			Spawnable spawnable = crateSpawner._spawnable;
			if (spawnable == null)
			{
				return false;
			}
			SpawnableCrateReference crateRef = spawnable.crateRef;
			if (crateRef == null)
			{
				return false;
			}
			if (!((ScannableReference)crateRef).IsValid() || (Object)(object)((CrateReferenceT<SpawnableCrate>)(object)crateRef).Crate == (Object)null)
			{
				return false;
			}
			if (CrateFilterer.HasTags((Crate)(object)((CrateReferenceT<SpawnableCrate>)(object)spawnable.crateRef).Crate, "Singleplayer Only"))
			{
				return true;
			}
			return false;
		}

		public static bool SpawnSpawnableAsyncPrefix(CrateSpawner __instance, bool isHidden, ref UniTask<Poolee> __result)
		{
			try
			{
				return HandleSpawnSpawnableAsync(__instance, isHidden, ref __result);
			}
			catch (Exception e)
			{
				FusionLogger.LogException("handling CrateSpawner.SpawnSpawnableAsync", e);
				return true;
			}
		}

		private static bool HandleSpawnSpawnableAsync(CrateSpawner __instance, bool isHidden, ref UniTask<Poolee> __result)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if (IsSingleplayerOnly(__instance))
			{
				return true;
			}
			if (!HasOwnership(__instance))
			{
				__result = new UniTask<Poolee>((Poolee)null);
				return false;
			}
			UniTaskCompletionSource<Poolee> val = new UniTaskCompletionSource<Poolee>();
			__result = new UniTask<Poolee>(((Il2CppObjectBase)val).TryCast<IUniTaskSource<Poolee>>(), (short)0);
			try
			{
				NetworkedSpawnSpawnable(__instance, val);
			}
			catch (Exception e)
			{
				FusionLogger.LogException("networking CrateSpawner " + ((Object)__instance).name, e);
			}
			return false;
		}

		private static bool HasOwnership(CrateSpawner spawner)
		{
			if (CrateSpawnerExtender.Cache.TryGet(spawner, out var value))
			{
				return value.IsOwner;
			}
			return NetworkSceneManager.IsLevelHost;
		}
	}
	[HarmonyPatch(typeof(Poolee), "OnDespawnEvent")]
	public class PooleeOnDespawnPatch
	{
		public static void Postfix(Poolee __instance)
		{
			if (NetworkSceneManager.IsLevelNetworked && PooleeExtender.Cache.TryGet(__instance, out var value) && value.GetExtender<NetworkProp>() != null)
			{
				NetworkEntityManager.IDManager.UnregisterEntity(value);
			}
		}
	}
	[HarmonyPatch(typeof(Poolee), "Despawn")]
	public class PooleeDespawnPatch
	{
		public static FrameBool IgnorePatch { get; set; } = false;


		private static bool CheckPlayerDespawn(Poolee __instance)
		{
			if (PooleeExtender.Cache.TryGet(__instance, out var value) && value.GetExtender<NetworkPlayer>() != null)
			{
				FusionLogger.Warn($"Prevented Poolee.Despawn of player at ID {value.ID}!");
				return true;
			}
			MarrowEntity val = MarrowEntity.Cache.Get(((Component)__instance).gameObject);
			if ((Object)(object)val != (Object)null && IMarrowEntityExtender.Cache.TryGet(val, out value) && value.GetExtender<NetworkPlayer>() != null)
			{
				FusionLogger.Warn($"Prevented Poolee.Despawn of player at ID {value.ID}!");
				return true;
			}
			return false;
		}

		public static bool Prefix(Poolee __instance)
		{
			if (!NetworkSceneManager.IsLevelNetworked)
			{
				return true;
			}
			if (CheckPlayerDespawn(__instance))
			{
				return false;
			}
			if ((bool)IgnorePatch)
			{
				return true;
			}
			if (!PooleeExtender.Cache.TryGet(__instance, out var value))
			{
				return true;
			}
			if (value.GetExtender<NetworkProp>() == null)
			{
				return true;
			}
			if (!NetworkSceneManager.IsLevelHost && !value.IsOwner)
			{
				return false;
			}
			NetworkAssetSpawner.DespawnRequestInfo info = default(NetworkAssetSpawner.DespawnRequestInfo);
			info.EntityID = value.ID;
			info.DespawnEffect = false;
			NetworkAssetSpawner.Despawn(info);
			return false;
		}
	}
}
namespace LabFusion.Marrow.Messages
{
	public class ButtonChargeData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 4;

		public byte smallId;

		public ushort entityId;

		public bool charged;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref smallId);
			serializer.SerializeValue(ref entityId);
			serializer.SerializeValue(ref charged);
		}

		public static ButtonChargeData Create(byte smallId, ushort entityId, bool charged)
		{
			return new ButtonChargeData
			{
				smallId = smallId,
				entityId = entityId,
				charged = charged
			};
		}
	}
	[Net.DelayWhileTargetLoading]
	public class ButtonChargeMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			ButtonChargeData buttonChargeData = received.ReadData<ButtonChargeData>();
			NetworkEntity entity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(buttonChargeData.entityId);
			if (entity != null)
			{
				ButtonControllerExtender extender = entity.GetExtender<ButtonControllerExtender>();
				if (extender != null)
				{
					extender.Charged = buttonChargeData.charged;
				}
			}
		}
	}
	public enum EventActuatorType : byte
	{
		ROSE,
		FELL,
		ROSEONESHOT
	}
	public class EventActuatorData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 14;

		public byte playerId;

		public ComponentHashData hashData;

		public EventActuatorType type;

		public float value;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref playerId);
			NetSerializerExtensions.SerializeValue(serializer, ref hashData);
			serializer.SerializeValue(ref type, Precision.OneByte);
			serializer.SerializeValue(ref value);
		}

		public static EventActuatorData Create(byte playerId, ComponentHashData hashData, EventActuatorType type, float value)
		{
			return new EventActuatorData
			{
				playerId = playerId,
				hashData = hashData,
				type = type,
				value = value
			};
		}
	}
	[Net.DelayWhileTargetLoading]
	public class EventActuatorMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			EventActuatorData eventActuatorData = received.ReadData<EventActuatorData>();
			EventActuator componentFromData = EventActuatorPatches.HashTable.GetComponentFromData(eventActuatorData.hashData);
			if (!((Object)(object)componentFromData == (Object)null))
			{
				OnFoundEventActuator(componentFromData, eventActuatorData.type, eventActuatorData.value);
			}
		}

		private static void OnFoundEventActuator(EventActuator actuator, EventActuatorType type, float value)
		{
			EventActuatorPatches.IgnoreOverride = true;
			try
			{
				switch (type)
				{
				case EventActuatorType.ROSE:
					actuator._invokeInputRose(value);
					break;
				case EventActuatorType.FELL:
					actuator._invokeInputFell(value);
					break;
				case EventActuatorType.ROSEONESHOT:
					actuator._invokeInputRoseOneShot(value);
					break;
				}
			}
			catch (Exception e)
			{
				FusionLogger.LogException($"executing EventActuator {type}", e);
			}
			EventActuatorPatches.IgnoreOverride = false;
		}
	}
	public class GunShotData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 4;

		public byte ammoCount;

		public ushort gunId;

		public byte gunIndex;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref ammoCount);
			serializer.SerializeValue(ref gunId);
			serializer.SerializeValue(ref gunIndex);
		}

		public static GunShotData Create(byte ammoCount, ushort gunId, byte gunIndex)
		{
			return new GunShotData
			{
				ammoCount = ammoCount,
				gunId = gunId,
				gunIndex = gunIndex
			};
		}
	}
	[Net.SkipHandleWhileLoading]
	public class GunShotMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			GunShotData gunShotData = received.ReadData<GunShotData>();
			NetworkEntity entity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(gunShotData.gunId);
			if (entity == null)
			{
				return;
			}
			GunExtender extender = entity.GetExtender<GunExtender>();
			if (extender != null)
			{
				Gun component = extender.GetComponent(gunShotData.gunIndex);
				component.hasFiredOnce = false;
				component.isTriggerPulledOnAttach = false;
				if (component._magState != null)
				{
					component._magState.SetCartridge(gunShotData.ammoCount + 1);
				}
				component.CeaseFire();
				component.Charge();
				if (!component.allowFireOnSlideGrabbed)
				{
					component.SlideGrabbedReleased();
				}
				GunPatches.IgnorePatches = true;
				component.Fire();
				GunPatches.IgnorePatches = false;
			}
		}
	}
	[Net.SkipHandleWhileLoading]
	public class PuppetMasterKillMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			if (!received.ReadData<NetworkEntityReference>().TryGetEntity(out var entity))
			{
				return;
			}
			PuppetMasterExtender extender = entity.GetExtender<PuppetMasterExtender>();
			if (extender != null)
			{
				PuppetMasterExtender.LastKilled = entity;
				PuppetMasterPatches.IgnorePatches = true;
				try
				{
					extender.Component.Kill();
				}
				catch (Exception e)
				{
					FusionLogger.LogException("executing PuppetMaster.Kill", e);
				}
				PuppetMasterPatches.IgnorePatches = false;
			}
		}
	}
	public class InventoryAmmoReceiverDropData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 2;

		public ushort EntityID;

		public int? GetSize()
		{
			return 2;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref EntityID);
		}
	}
	[Net.SkipHandleWhileLoading]
	public class InventoryAmmoReceiverDropMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			InventoryAmmoReceiverDropData inventoryAmmoReceiverDropData = received.ReadData<InventoryAmmoReceiverDropData>();
			NetworkEntity entity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(inventoryAmmoReceiverDropData.EntityID);
			if (entity != null)
			{
				InventoryAmmoReceiverExtender extender = entity.GetExtender<InventoryAmmoReceiverExtender>();
				if (extender != null)
				{
					InventoryAmmoReceiver component = extender.Component;
					LocalAudioPlayer.PlayAtPoint(Il2CppArrayBase<AudioClip>.op_Implicit((Il2CppArrayBase<AudioClip>)(object)component.grabClips), ((Component)component).transform.position, new AudioPlayerSettings
					{
						Mixer = LocalAudioPlayer.SoftInteraction,
						Volume = 0.2f
					});
				}
			}
		}
	}
	public class InventorySlotDropData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 5;

		public ushort SlotEntityID;

		public byte GrabberID;

		public byte SlotIndex;

		public Handedness Handedness;

		public int? GetSize()
		{
			return 5;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref SlotEntityID);
			serializer.SerializeValue(ref GrabberID);
			serializer.SerializeValue(ref SlotIndex);
			serializer.SerializeValue<Handedness>(ref Handedness, Precision.OneByte);
		}
	}
	[Net.SkipHandleWhileLoading]
	public class InventorySlotDropMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			InventorySlotDropData inventorySlotDropData = received.ReadData<InventorySlotDropData>();
			NetworkEntity entity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(inventorySlotDropData.SlotEntityID);
			if (entity == null)
			{
				return;
			}
			InventorySlotReceiverExtender extender = entity.GetExtender<InventorySlotReceiverExtender>();
			if (extender == null)
			{
				return;
			}
			InventorySlotReceiver component = extender.GetComponent(inventorySlotDropData.SlotIndex);
			WeaponSlot slottedWeapon = component._slottedWeapon;
			InventorySlotReceiverPatches.IgnorePatches = true;
			try
			{
				component.DropWeapon();
			}
			catch (Exception e)
			{
				FusionLogger.LogException("executing InventorySlotReceiver.DropWeapon", e);
			}
			InventorySlotReceiverPatches.IgnorePatches = false;
			if ((int)inventorySlotDropData.Handedness != 0 && NetworkPlayerManager.TryGetPlayer(inventorySlotDropData.GrabberID, out var player) && !player.NetworkEntity.IsOwner)
			{
				if (Object.op_Implicit((Object)(object)slottedWeapon) && Object.op_Implicit((Object)(object)slottedWeapon.grip))
				{
					slottedWeapon.grip.MoveIntoHand(player.RigRefs.GetHand(inventorySlotDropData.Handedness));
				}
				Hand hand = player.RigRefs.GetHand(inventorySlotDropData.Handedness);
				if (Object.op_Implicit((Object)(object)hand))
				{
					((Component)hand).gameObject.GetComponent<HandSFX>().BodySlot();
				}
			}
		}
	}
	public class InventorySlotInsertData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 5;

		public ushort SlotEntityID;

		public ushort WeaponID;

		public byte SlotIndex;

		public int? GetSize()
		{
			return 5;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref SlotEntityID);
			serializer.SerializeValue(ref WeaponID);
			serializer.SerializeValue(ref SlotIndex);
		}
	}
	[Net.SkipHandleWhileLoading]
	public class InventorySlotInsertMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			InventorySlotInsertData data = received.ReadData<InventorySlotInsertData>();
			NetworkEntity weaponEntity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(data.WeaponID);
			NetworkEntity slotEntity;
			if (weaponEntity != null)
			{
				slotEntity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(data.SlotEntityID);
				if (slotEntity != null)
				{
					slotEntity.GetExtender<IMarrowEntityExtender>()?.HookOnReady(OnSlotReady);
				}
			}
			void OnSlotReady()
			{
				WeaponSlotExtender extender = weaponEntity.GetExtender<WeaponSlotExtender>();
				if (extender != null)
				{
					InventorySlotReceiverExtender extender2 = slotEntity.GetExtender<InventorySlotReceiverExtender>();
					if (extender2 != null)
					{
						extender.Component.interactableHost.TryDetach();
						InventorySlotReceiverPatches.IgnorePatches = true;
						try
						{
							extender2.GetComponent(data.SlotIndex).InsertInSlot(extender.Component.interactableHost);
						}
						catch (Exception e)
						{
							FusionLogger.LogException("handling InventorySlotInsertMessage", e);
						}
						InventorySlotReceiverPatches.IgnorePatches = false;
					}
				}
			}
		}
	}
	public class ConstrainerModeData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 3;

		public ushort ConstrainerID;

		public ConstraintMode Mode;

		public int? GetSize()
		{
			return 3;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref ConstrainerID);
			serializer.SerializeValue<ConstraintMode>(ref Mode, Precision.OneByte);
		}

		public static ConstrainerModeData Create(byte smallId, ushort constrainerId, ConstraintMode mode)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return new ConstrainerModeData
			{
				ConstrainerID = constrainerId,
				Mode = mode
			};
		}
	}
	[Net.SkipHandleWhileLoading]
	public class ConstrainerModeMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			ConstrainerModeData constrainerModeData = received.ReadData<ConstrainerModeData>();
			NetworkEntity entity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(constrainerModeData.ConstrainerID);
			if (entity != null)
			{
				ConstrainerExtender extender = entity.GetExtender<ConstrainerExtender>();
				if (extender != null)
				{
					extender.Component.mode = constrainerModeData.Mode;
				}
			}
		}
	}
	public class ConstraintCreateData : LabFusion.Network.Serialization.INetSerializable
	{
		public byte SmallID;

		public ushort? ConstrainerID;

		public ConstraintMode Mode;

		public GameObjectReference Tracker1;

		public GameObjectReference Tracker2;

		public SerializedTransform Tracker1Transform;

		public SerializedTransform Tracker2Transform;

		public Vector3 Point1;

		public Vector3 Point2;

		public Vector3 Normal1;

		public Vector3 Normal2;

		public ushort Point1Id;

		public ushort Point2Id;

		public int? GetSize()
		{
			return 5 + Tracker1.GetSize() + Tracker2.GetSize() + 38 + 48 + 4;
		}

		public void Serialize(INetSerializer serializer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			Vector3 value = NetworkTransformManager.EncodePosition(Point1);
			Vector3 value2 = NetworkTransformManager.EncodePosition(Point2);
			serializer.SerializeValue(ref SmallID);
			serializer.SerializeValue(ref ConstrainerID);
			serializer.SerializeValue<ConstraintMode>(ref Mode, Precision.OneByte);
			NetSerializerExtensions.SerializeValue(serializer, ref Tracker1);
			NetSerializerExtensions.SerializeValue(serializer, ref Tracker2);
			NetSerializerExtensions.SerializeValue(serializer, ref Tracker1Transform);
			NetSerializerExtensions.SerializeValue(serializer, ref Tracker2Transform);
			NetSerializerUnityExtensions.SerializeValue(serializer, ref value);
			NetSerializerUnityExtensions.SerializeValue(serializer, ref value2);
			NetSerializerUnityExtensions.SerializeValue(serializer, ref Normal1);
			NetSerializerUnityExtensions.SerializeValue(serializer, ref Normal2);
			serializer.SerializeValue(ref Point1Id);
			serializer.SerializeValue(ref Point2Id);
			if (serializer.IsReader)
			{
				Point1 = NetworkTransformManager.DecodePosition(value);
				Point2 = NetworkTransformManager.DecodePosition(value2);
			}
		}

		public static ConstraintCreateData Create(byte smallId, ushort? constrainerId, ConstrainerPointPair pair)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			return new ConstraintCreateData
			{
				SmallID = smallId,
				ConstrainerID = constrainerId,
				Mode = pair.mode,
				Tracker1 = new GameObjectReference(pair.go1),
				Tracker2 = new GameObjectReference(pair.go2),
				Tracker1Transform = new SerializedTransform(pair.go1.transform),
				Tracker2Transform = new SerializedTransform(pair.go2.transform),
				Point1 = pair.point1,
				Point2 = pair.point2,
				Normal1 = pair.normal1,
				Normal2 = pair.normal2,
				Point1Id = 0,
				Point2Id = 0
			};
		}
	}
	[Net.DelayWhileTargetLoading]
	public class ConstraintCreateMessage : ModuleMessageHandler
	{
		public const int MaxConstraintsPerSecond = 4;

		protected override void OnHandleMessage(ReceivedMessage received)
		{
			ConstraintCreateData data = received.ReadData<ConstraintCreateData>();
			NetworkEntity constrainerEntity = (data.ConstrainerID.HasValue ? NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(data.ConstrainerID.Value) : null);
			bool hasConstrainer = constrainerEntity != null;
			if (received.IsServerHandled)
			{
				if (!NetworkSceneManager.PlayerIsLevelHost(PlayerIDManager.GetPlayerID(received.Sender.Value)))
				{
					LimitedActivityTracker.Activity activity = LimitedActivityManager.GetTracker("ConstraintCreateMessage").GetActivity(received.Sender.Value);
					activity.Increment();
					if (activity.Counter > 4)
					{
						FusionLogger.Warn($"Blocking Player {received.Sender.Value}'s constraint creation because they have tried to spawn {activity.Counter} entities in one second!");
						return;
					}
				}
				if (hasConstrainer)
				{
					data.Point1Id = NetworkEntityManager.IDManager.RegisteredEntities.AllocateNewID();
					data.Point2Id = NetworkEntityManager.IDManager.RegisteredEntities.AllocateNewID();
					MessageRelay.RelayModule<ConstraintCreateMessage, ConstraintCreateData>(data, CommonMessageRoutes.ReliableToClients);
				}
			}
			else
			{
				data.Tracker1.HookGameObjectFound(OnFirstTrackerFound);
			}
			void OnConstrainerReady()
			{
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0147: Unknown result type (might be due to invalid IL or missing references)
				//IL_014c: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_0157: Unknown result type (might be due to invalid IL or missing references)
				//IL_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0191: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0202: Unknown result type (might be due to invalid IL or missing references)
				//IL_0204: Unknown result type (might be due to invalid IL or missing references)
				//IL_020b: Unknown result type (might be due to invalid IL or missing references)
				//IL_020d: Unknown result type (might be due to invalid IL or missing references)
				NetworkPlayer player;
				bool flag = TryGetPlayer(data.Tracker1, out player);
				NetworkPlayer player2;
				bool flag2 = TryGetPlayer(data.Tracker2, out player2);
				if (ConstrainerUtilities.PlayerConstraintsEnabled || !(flag || flag2))
				{
					Constrainer val = null;
					if (hasConstrainer)
					{
						val = constrainerEntity.GetExtender<ConstrainerExtender>()?.Component;
					}
					hasConstrainer = (Object)(object)val != (Object)null;
					Constrainer globalConstrainer = ConstrainerUtilities.GlobalConstrainer;
					globalConstrainer.mode = data.Mode;
					globalConstrainer._point1 = data.Point1;
					globalConstrainer._point2 = data.Point2;
					globalConstrainer._normal1 = data.Normal1;
					globalConstrainer._normal2 = data.Normal2;
					globalConstrainer._gO1 = data.Tracker1.GameObject;
					globalConstrainer._gO2 = data.Tracker2.GameObject;
					globalConstrainer._mb1 = data.Tracker1.Body;
					globalConstrainer._mb2 = data.Tracker2.Body;
					Transform transform = globalConstrainer._gO1.transform;
					Transform transform2 = globalConstrainer._gO2.transform;
					Vector3 position = transform.position;
					Quaternion rotation = transform.rotation;
					Vector3 position2 = transform2.position;
					Quaternion rotation2 = transform2.rotation;
					transform.SetPositionAndRotation(data.Tracker1Transform.position, data.Tracker1Transform.rotation);
					transform2.SetPositionAndRotation(data.Tracker2Transform.position, data.Tracker2Transform.rotation);
					ConstrainerPatches.IsReceivingConstraints = true;
					ConstrainerPatches.FirstId = data.Point1Id;
					ConstrainerPatches.SecondId = data.Point2Id;
					if (hasConstrainer)
					{
						globalConstrainer.LineMaterial = val.LineMaterial;
					}
					globalConstrainer.PrimaryButtonUp();
					ConstrainerPatches.FirstId = 0;
					ConstrainerPatches.SecondId = 0;
					ConstrainerPatches.IsReceivingConstraints = false;
					transform.SetPositionAndRotation(position, rotation);
					transform2.SetPositionAndRotation(position2, rotation2);
					if (data.SmallID != PlayerIDManager.LocalSmallID)
					{
						if (hasConstrainer)
						{
							val.sfx.GravLocked();
							val.sfx.Release();
						}
						if (data.SmallID == 0 && AchievementManager.TryGetAchievement<ClassStruggle>(out var achievement))
						{
							bool flag3 = flag && player.NetworkEntity.IsOwner;
							bool flag4 = flag2 && player2.NetworkEntity.IsOwner;
							if (!achievement.IsComplete && (flag3 || flag4))
							{
								achievement.IncrementTask();
							}
						}
					}
				}
			}
			void OnFirstTrackerFound(GameObject tracker1)
			{
				data.Tracker2.HookGameObjectFound(OnSecondTrackerFound);
			}
			void OnSecondTrackerFound(GameObject tracker2)
			{
				ConstrainerUtilities.HookConstrainerCreated(OnConstrainerReady);
			}
		}

		private static bool TryGetPlayer(GameObjectReference reference, out NetworkPlayer player)
		{
			player = null;
			if (!reference.Entity.HasValue)
			{
				return false;
			}
			if (!reference.Entity.Value.TryGetEntity(out var entity))
			{
				return false;
			}
			player = entity.GetExtender<NetworkPlayer>();
			return player != null;
		}
	}
	public class ConstraintDeleteData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 2;

		public ushort ConstraintID;

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref ConstraintID);
		}
	}
	[Net.DelayWhileTargetLoading]
	public class ConstraintDeleteMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			ConstraintDeleteData constraintDeleteData = received.ReadData<ConstraintDeleteData>();
			NetworkEntity entity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(constraintDeleteData.ConstraintID);
			if (entity == null)
			{
				return;
			}
			NetworkConstraint extender = entity.GetExtender<NetworkConstraint>();
			if (extender != null)
			{
				ConstraintTrackerPatches.IgnorePatches = true;
				try
				{
					extender.Tracker.DeleteConstraint();
				}
				catch (Exception e)
				{
					FusionLogger.LogException("deleting constraint", e);
				}
				ConstraintTrackerPatches.IgnorePatches = false;
				NetworkEntityManager.IDManager.UnregisterEntity(entity);
			}
		}
	}
	public class MagazineClaimData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 4;

		public byte OwnerID;

		public ushort EntityID;

		public Handedness Handedness;

		public int? GetSize()
		{
			return 4;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref OwnerID);
			serializer.SerializeValue(ref EntityID);
			serializer.SerializeValue<Handedness>(ref Handedness, Precision.OneByte);
		}
	}
	[Net.SkipHandleWhileLoading]
	public class MagazineClaimMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			MagazineClaimData magazineClaimData = received.ReadData<MagazineClaimData>();
			NetworkEntity entity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(magazineClaimData.EntityID);
			if (entity != null)
			{
				MagazineExtender extender = entity.GetExtender<MagazineExtender>();
				if (extender != null && NetworkPlayerManager.TryGetPlayer(magazineClaimData.OwnerID, out var player))
				{
					MagazineUtilities.GrabMagazine(extender.Component, player, magazineClaimData.Handedness);
				}
			}
		}
	}
	public class MagazineEjectData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 6;

		public byte PlayerID;

		public ushort MagazineID;

		public ushort GunID;

		public Handedness Handedness;

		public int? GetSize()
		{
			return 6;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref PlayerID);
			serializer.SerializeValue(ref MagazineID);
			serializer.SerializeValue(ref GunID);
			serializer.SerializeValue<Handedness>(ref Handedness, Precision.OneByte);
		}
	}
	[Net.SkipHandleWhileLoading]
	public class MagazineEjectMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			MagazineEjectData magazineEjectData = received.ReadData<MagazineEjectData>();
			NetworkEntity entity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(magazineEjectData.GunID);
			if (entity == null)
			{
				return;
			}
			AmmoSocketExtender extender = entity.GetExtender<AmmoSocketExtender>();
			if (extender == null)
			{
				return;
			}
			AmmoSocket component = extender.Component;
			if (!Object.op_Implicit((Object)(object)component._magazinePlug))
			{
				return;
			}
			AmmoPlug magazinePlug = component._magazinePlug;
			if (!Object.op_Implicit((Object)(object)magazinePlug.magazine))
			{
				return;
			}
			NetworkEntity networkEntity = MagazineExtender.Cache.Get(magazinePlug.magazine);
			if (networkEntity == null || networkEntity.ID != magazineEjectData.MagazineID)
			{
				return;
			}
			AmmoSocketPatches.IgnorePatch = true;
			try
			{
				((AlignPlug)(object)magazinePlug).ForceEject();
				if ((int)magazineEjectData.Handedness != 0 && NetworkPlayerManager.TryGetPlayer(magazineEjectData.PlayerID, out var player) && !player.NetworkEntity.IsOwner)
				{
					player.Grabber.Attach(magazineEjectData.Handedness, magazinePlug.magazine.grip);
				}
			}
			catch (Exception e)
			{
				FusionLogger.LogException("ejecting AmmoPlug", e);
			}
			AmmoSocketPatches.IgnorePatch = false;
		}
	}
	public class MagazineInsertData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 4;

		public ushort MagazineID;

		public ushort GunID;

		public int? GetSize()
		{
			return 4;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref MagazineID);
			serializer.SerializeValue(ref GunID);
		}
	}
	[Net.SkipHandleWhileLoading]
	public class MagazineInsertMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			MagazineInsertData magazineInsertData = received.ReadData<MagazineInsertData>();
			NetworkEntity entity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(magazineInsertData.MagazineID);
			if (entity == null)
			{
				return;
			}
			MagazineExtender extender = entity.GetExtender<MagazineExtender>();
			if (extender == null)
			{
				return;
			}
			NetworkEntity entity2 = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(magazineInsertData.GunID);
			if (entity2 == null)
			{
				return;
			}
			AmmoSocketExtender extender2 = entity2.GetExtender<AmmoSocketExtender>();
			if (extender2 == null)
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)extender2.Component._magazinePlug))
			{
				AmmoPlug magazinePlug = extender2.Component._magazinePlug;
				if ((Object)(object)magazinePlug != (Object)(object)extender.Component.magazinePlug)
				{
					AmmoSocketPatches.IgnorePatch = true;
					try
					{
						if (Object.op_Implicit((Object)(object)magazinePlug))
						{
							((AlignPlug)(object)magazinePlug).ForceEject();
						}
					}
					catch (Exception e)
					{
						FusionLogger.LogException("ejecting other AmmoPlug", e);
					}
					AmmoSocketPatches.IgnorePatch = false;
				}
			}
			((Plug)extender.Component.magazinePlug).host.TryDetach();
			AmmoSocketPatches.IgnorePatch = true;
			try
			{
				((AlignPlug)extender.Component.magazinePlug).InsertPlug((Socket)(object)extender2.Component);
			}
			catch (Exception e2)
			{
				FusionLogger.LogException("inserting AmmoPlug", e2);
			}
			AmmoSocketPatches.IgnorePatch = false;
		}
	}
	public class NimbusGunNoClipData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 3;

		public ushort NimbusGunID;

		public bool NoClip;

		public int? GetSize()
		{
			return 3;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref NimbusGunID);
			serializer.SerializeValue(ref NoClip);
		}
	}
	[Net.SkipHandleWhileLoading]
	public class NimbusGunNoClipMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			NimbusGunNoClipData nimbusGunNoClipData = received.ReadData<NimbusGunNoClipData>();
			NetworkEntity entity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(nimbusGunNoClipData.NimbusGunID);
			if (entity == null || received.Sender != entity.OwnerID.SmallID)
			{
				return;
			}
			FlyingGunExtender extender = entity.GetExtender<FlyingGunExtender>();
			if (extender == null)
			{
				return;
			}
			FlyingGun component = extender.Component;
			if (nimbusGunNoClipData.NoClip)
			{
				component.EnableNoClip();
				component.sfx.Release();
			}
			else if (Object.op_Implicit((Object)(object)component.triggerGrip))
			{
				Hand hand = component.triggerGrip.GetHand();
				if (Object.op_Implicit((Object)(object)hand))
				{
					component.DisableNoClip(hand);
					component.sfx.Grab();
				}
			}
		}
	}
	[Net.SkipHandleWhileLoading]
	public class ObjectDestructibleDestroyMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			ComponentIndexData componentIndexData = received.ReadData<ComponentIndexData>();
			NetworkEntity entity = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(componentIndexData.EntityID);
			if (entity == null)
			{
				return;
			}
			ObjectDestructibleExtender extender = entity.GetExtender<ObjectDestructibleExtender>();
			if (extender != null)
			{
				ObjectDestructible component = extender.GetComponent(componentIndexData.ComponentIndex);
				ObjectDestructiblePatches.IgnorePatches = true;
				try
				{
					component._hits = component.reqHitCount + 1;
					component.TakeDamage(Vector3Extensions.up, component._health + 1f, false, (AttackType)64);
				}
				catch (Exception e)
				{
					FusionLogger.LogException("destroying ObjectDestructible", e);
				}
				ObjectDestructiblePatches.IgnorePatches = false;
			}
		}
	}
	public class CrateSpawnerData : LabFusion.Network.Serialization.INetSerializable
	{
		public const int Size = 16;

		public ushort SpawnedID;

		public ComponentPathData PathData;

		public int? GetSize()
		{
			return 16;
		}

		public void Serialize(INetSerializer serializer)
		{
			serializer.SerializeValue(ref SpawnedID);
			NetSerializerExtensions.SerializeValue(serializer, ref PathData);
		}
	}
	[Net.SkipHandleWhileLoading]
	public class CrateSpawnerMessage : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			CrateSpawnerData crateSpawnerData = received.ReadData<CrateSpawnerData>();
			if (!crateSpawnerData.PathData.TryGetComponent<CrateSpawner, CrateSpawnerExtender>(CrateSpawnerPatches.HashTable, out CrateSpawner crateSpawner))
			{
				return;
			}
			NetworkEntity entity2 = NetworkEntityManager.IDManager.RegisteredEntities.GetEntity(crateSpawnerData.SpawnedID);
			if (entity2 == null)
			{
				return;
			}
			PooleeExtender extender = entity2.GetExtender<PooleeExtender>();
			if (extender != null)
			{
				crateSpawner.OnFinishNetworkSpawn(((Component)extender.Component).gameObject);
				entity2.OnEntityDataCatchup += delegate(NetworkEntity entity, PlayerID player)
				{
					SendCrateSpawnerMessage(crateSpawner, entity.ID, player);
				};
			}
		}

		public static void SendCrateSpawnerMessage(CrateSpawner crateSpawner, ushort entityID, PlayerID target = null)
		{
			CrateSpawnerData data = new CrateSpawnerData
			{
				SpawnedID = entityID,
				PathData = ComponentPathData.CreateFromComponent<CrateSpawner, CrateSpawnerExtender>(crateSpawner, CrateSpawnerPatches.HashTable, CrateSpawnerExtender.Cache)
			};
			if (target != null)
			{
				MessageRelay.RelayModule<CrateSpawnerMessage, CrateSpawnerData>(data, new MessageRoute(target.SmallID, NetworkChannel.Reliable));
			}
			else
			{
				MessageRelay.RelayModule<CrateSpawnerMessage, CrateSpawnerData>(data, CommonMessageRoutes.ReliableToClients);
			}
		}
	}
}
namespace LabFusion.Marrow.Extensions
{
	public static class MarrowEntityExtensions
	{
		public static void ResetPose(this MarrowEntity entity, bool resetVelocity = true)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < ((Il2CppArrayBase<SimpleTransform>)(object)entity._defaultPoseCache).Length; i++)
			{
				SimpleTransform val = ((Il2CppArrayBase<SimpleTransform>)(object)entity._defaultPoseCache)[i];
				MarrowBody val2 = ((Il2CppArrayBase<MarrowBody>)(object)entity.Bodies)[i];
				((Component)val2).transform.localPosition = val.position;
				((Component)val2).transform.localRotation = val.rotation;
				if (resetVelocity)
				{
					Rigidbody rigidbody = val2._rigidbody;
					if (!((Object)(object)rigidbody == (Object)null))
					{
						rigidbody.velocity = Vector3.zero;
						rigidbody.angularVelocity = Vector3.zero;
					}
				}
			}
		}
	}
}
namespace LabFusion.Marrow.Extenders
{
	public class AmmoSocketExtender : EntityComponentExtender<AmmoSocket>
	{
		protected override void OnRegister(NetworkEntity entity, AmmoSocket component)
		{
			entity.OnEntityDataCatchup += OnEntityDataCatchup;
		}

		protected override void OnUnregister(NetworkEntity entity, AmmoSocket component)
		{
			entity.OnEntityDataCatchup -= OnEntityDataCatchup;
		}

		private void OnEntityDataCatchup(NetworkEntity entity, PlayerID player)
		{
			if ((Object)(object)((Socket)base.Component).LockedPlug == (Object)null || !Object.op_Implicit((Object)(object)base.Component.gun))
			{
				return;
			}
			NetworkEntity gunEntity = GunExtender.Cache.Get(base.Component.gun);
			if (gunEntity == null)
			{
				return;
			}
			AmmoPlug val = ((Il2CppObjectBase)((Socket)base.Component).LockedPlug).TryCast<AmmoPlug>();
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.magazine == (Object)null))
			{
				MagazineExtender.Cache.Get(val.magazine)?.HookOnDataCatchup(player, delegate(NetworkEntity magEntity, PlayerID magPlayer)
				{
					MessageRelay.RelayModule<MagazineInsertMessage, MagazineInsertData>(new MagazineInsertData
					{
						MagazineID = magEntity.ID,
						GunID = gunEntity.ID
					}, new MessageRoute(player.SmallID, NetworkChannel.Reliable));
				});
			}
		}
	}
	public class AtvExtender : EntityComponentExtender<Atv>
	{
		private Action _onSeatRegistered;

		private Action _onSeatDeregistered;

		protected override void OnRegister(NetworkEntity entity, Atv component)
		{
			Seat driverSeat = component.driverSeat;
			if ((Object)(object)driverSeat != (Object)null)
			{
				_onSeatRegistered = Action.op_Implicit((Action)OnSeatRegistered);
				_onSeatDeregistered = Action.op_Implicit((Action)OnSeatDeregistered);
				driverSeat.RegisteredEvent += _onSeatRegistered;
				driverSeat.DeRegisteredEvent += _onSeatDeregistered;
			}
		}

		protected override void OnUnregister(NetworkEntity entity, Atv component)
		{
			Seat driverSeat = component.driverSeat;
			if ((Object)(object)driverSeat != (Object)null)
			{
				driverSeat.RegisteredEvent -= _onSeatRegistered;
				driverSeat.DeRegisteredEvent -= _onSeatDeregistered;
			}
			_onSeatRegistered = null;
			_onSeatDeregistered = null;
		}

		protected void OnSeatRegistered()
		{
			Seat driverSeat = base.Component.driverSeat;
			if (!((Object)(object)driverSeat == (Object)null) && NetworkPlayerManager.TryGetPlayer(driverSeat.rigManager, out var player))
			{
				base.NetworkEntity.SetOwner(player.PlayerID);
				base.NetworkEntity.LockOwner();
			}
		}

		protected void OnSeatDeregistered()
		{
			base.NetworkEntity.UnlockOwner();
		}
	}
	public class ButtonControllerExtender : EntityComponentExtender<ButtonController>
	{
		public static readonly FusionComponentCache<ButtonController, NetworkEntity> Cache = new FusionComponentCache<ButtonController, NetworkEntity>();

		public bool Charged { get; set; }

		protected override void OnRegister(NetworkEntity networkEntity, ButtonController component)
		{
			Cache.Add(component, networkEntity);
		}

		protected override void OnUnregister(NetworkEntity networkEntity, ButtonController component)
		{
			Cache.Remove(component);
		}
	}
	public class CircuitSocketExtender : EntityComponentExtender<CircuitSocket>
	{
		[CompilerGenerated]
		private sealed class <FindExternalCircuit>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public CircuitSocketExtender <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <FindExternalCircuit>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				CircuitSocketExtender circuitSocketExtender = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (circuitSocketExtender._registered && Object.op_Implicit((Object)(object)circuitSocketExtender.Component) && !Object.op_Implicit((Object)(object)((Circuit)circuitSocketExtender.Component).externalCircuit))
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if (!circuitSocketExtender._registered)
				{
					return false;
				}
				if ((Object)(object)circuitSocketExtender.Component != (Object)null && Object.op_Implicit((Object)(object)((Circuit)circuitSocketExtender.Component).externalCircuit))
				{
					circuitSocketExtender.OnExternalCircuitFound(((Circuit)circuitSocketExtender.Component).externalCircuit);
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static readonly FusionComponentCache<CircuitSocket, NetworkEntity> Cache = new FusionComponentCache<CircuitSocket, NetworkEntity>();

		public static readonly FusionComponentCache<ExternalCircuit, CircuitSocket> ExternalCache = new FusionComponentCache<ExternalCircuit, CircuitSocket>();

		private bool _registered;

		protected override void OnRegister(NetworkEntity networkEntity, CircuitSocket component)
		{
			Cache.Add(component, networkEntity);
			_registered = true;
			MelonCoroutines.Start(FindExternalCircuit());
		}

		protected override void OnUnregister(NetworkEntity networkEntity, CircuitSocket component)
		{
			Cache.Remove(component);
			_registered = false;
			OnExternalCircuitRemoved();
		}

		[IteratorStateMachine(typeof(<FindExternalCircuit>d__5))]
		private IEnumerator FindExternalCircuit()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FindExternalCircuit>d__5(0)
			{
				<>4__this = this
			};
		}

		private void OnExternalCircuitFound(ExternalCircuit externalCircuit)
		{
			ExternalCache.Add(externalCircuit, base.Component);
		}

		private void OnExternalCircuitRemoved()
		{
			if (!((Object)(object)((Circuit)base.Component).externalCircuit == (Object)null))
			{
				ExternalCache.Remove(((Circuit)base.Component).externalCircuit);
			}
		}
	}
	public class ConstrainerExtender : EntityComponentExtender<Constrainer>
	{
		public static readonly FusionComponentCache<Constrainer, NetworkEntity> Cache = new FusionComponentCache<Constrainer, NetworkEntity>();

		private HandDelegate _onAttachDelegate;

		private Poolee _poolee;

		protected override void OnRegister(NetworkEntity entity, Constrainer component)
		{
			Cache.Add(component, entity);
			if (NetworkSceneManager.IsLevelHost)
			{
				_poolee = Poolee.Cache.Get(((Component)component).gameObject);
				_onAttachDelegate = HandDelegate.op_Implicit((Action<Hand>)delegate(Hand hand)
				{
					OnAttach(hand);
				});
				Grip triggerGrip = component.triggerGrip;
				triggerGrip.attachedHandDelegate += _onAttachDelegate;
			}
		}

		protected override void OnUnregister(NetworkEntity entity, Constrainer component)
		{
			Cache.Remove(component);
			if ((Delegate)(object)_onAttachDelegate != (Delegate)null)
			{
				Grip triggerGrip = component.triggerGrip;
				triggerGrip.attachedHandDelegate -= _onAttachDelegate;
				_onAttachDelegate = null;
				_poolee = null;
			}
		}

		private void OnAttach(Hand hand)
		{
			if (!((Object)(object)_poolee == (Object)null) && NetworkPlayerManager.TryGetPlayer(hand.manager, out var player) && FusionDevTools.DespawnConstrainer(player.PlayerID))
			{
				_poolee.Despawn();
			}
		}
	}
	public class CrateSpawnerExtender : EntityComponentArrayExtender<CrateSpawner>
	{
		public static readonly FusionComponentCache<CrateSpawner, NetworkEntity> Cache = new FusionComponentCache<CrateSpawner, NetworkEntity>();

		protected override void OnRegister(NetworkEntity entity, CrateSpawner[] components)
		{
			foreach (CrateSpawner source in components)
			{
				Cache.Add(source, entity);
			}
		}

		protected override void OnUnregister(NetworkEntity entity, CrateSpawner[] components)
		{
			foreach (CrateSpawner source in components)
			{
				Cache.Remove(source);
			}
		}
	}
	public class FlyingGunExtender : EntityComponentExtender<FlyingGun>
	{
		public static readonly FusionComponentCache<FlyingGun, NetworkEntity> Cache = new FusionComponentCache<FlyingGun, NetworkEntity>();

		private EntityCleaner _cleaner;

		private HandDelegate _onAttachDelegate;

		private Poolee _poolee;

		protected override void OnRegister(NetworkEntity entity, FlyingGun component)
		{
			Cache.Add(component, entity);
			RegisterCleaner();
			if (NetworkInfo.IsHost)
			{
				_poolee = ((MarrowBehaviour)component._host).marrowEntity._poolee;
				_onAttachDelegate = HandDelegate.op_Implicit((Action<Hand>)delegate(Hand hand)
				{
					OnAttach(hand);
				});
				Grip triggerGrip = component.triggerGrip;
				triggerGrip.attachedHandDelegate += _onAttachDelegate;
			}
		}

		protected override void OnUnregister(NetworkEntity entity, FlyingGun component)
		{
			Cache.Remove(component);
			UnregisterCleaner();
			if ((Delegate)(object)_onAttachDelegate != (Delegate)null)
			{
				Grip triggerGrip = component.triggerGrip;
				triggerGrip.attachedHandDelegate -= _onAttachDelegate;
				_onAttachDelegate = null;
				_poolee = null;
			}
		}

		private void RegisterCleaner()
		{
			if (base.NetworkEntity.Source == EntitySource.Player)
			{
				_cleaner = new EntityCleaner();
				_cleaner.Register(base.NetworkEntity, base.Component._host, ((MarrowBehaviour)base.Component._host).marrowEntity._poolee);
			}
		}

		private void UnregisterCleaner()
		{
			if (_cleaner != null)
			{
				_cleaner.Unregister();
				_cleaner = null;
			}
		}

		private void OnAttach(Hand hand)
		{
			if (!((Object)(object)_poolee == (Object)null) && NetworkPlayerManager.TryGetPlayer(hand.manager, out var player) && FusionDevTools.DespawnDevTool(player.PlayerID))
			{
				_poolee.Despawn();
			}
		}
	}
	public class GripExtender : EntityComponentArrayExtender<Grip>
	{
		public static readonly FusionComponentCache<Grip, NetworkEntity> Cache = new FusionComponentCache<Grip, NetworkEntity>();

		private HandDelegate _onAttachDelegate;

		private HandDelegate _onDetachDelegate;

		protected override void OnRegister(NetworkEntity entity, Grip[] components)
		{
			_onAttachDelegate = HandDelegate.op_Implicit((Action<Hand>)delegate(Hand hand)
			{
				OnAttach(hand);
			});
			_onDetachDelegate = HandDelegate.op_Implicit((Action<Hand>)delegate(Hand hand)
			{
				OnDetach(hand);
			});
			foreach (Grip val in components)
			{
				Cache.Add(val, entity);
				val.attachedHandDelegate += _onAttachDelegate;
				val.detachedHandDelegate += _onDetachDelegate;
			}
			entity.OnEntityDataCatchup += OnEntityDataCatchup;
		}

		protected override void OnUnregister(NetworkEntity entity, Grip[] components)
		{
			foreach (Grip val in components)
			{
				Cache.Remove(val);
				val.attachedHandDelegate -= _onAttachDelegate;
				val.detachedHandDelegate -= _onDetachDelegate;
			}
			_onAttachDelegate = null;
			_onDetachDelegate = null;
			entity.OnEntityDataCatchup -= OnEntityDataCatchup;
		}

		protected void OnAttach(Hand hand)
		{
			OnTransferOwner(hand);
		}

		protected void OnDetach(Hand hand)
		{
			Grip[] components = base.Components;
			for (int i = 0; i < components.Length; i++)
			{
				Enumerator<Hand> enumerator = components[i].attachedHands.GetEnumerator();
				while (enumerator.MoveNext())
				{
					if ((Object)(object)enumerator.Current.manager != (Object)(object)hand.manager)
					{
						return;
					}
				}
			}
			OnTransferOwner(hand);
		}

		public bool IsHeldBy(RigManager rigManager)
		{
			Grip[] components = base.Components;
			for (int i = 0; i < components.Length; i++)
			{
				Enumerator<Hand> enumerator = components[i].attachedHands.GetEnumerator();
				while (enumerator.MoveNext())
				{
					Hand current = enumerator.Current;
					if (current.HasAttachedObject() && (Object)(object)current.manager == (Object)(object)rigManager)
					{
						return true;
					}
				}
			}
			return false;
		}

		public bool CheckHeld()
		{
			Grip[] components = base.Components;
			for (int i = 0; i < components.Length; i++)
			{
				if (components[i].attachedHands.Count > 0)
				{
					return true;
				}
			}
			return false;
		}

		public void OnTransferOwner(Hand hand)
		{
			if (!base.NetworkEntity.IsOwnerLocked && hand.manager.IsLocalPlayer())
			{
				NetworkEntityManager.TakeOwnership(base.NetworkEntity);
			}
		}

		private void OnEntityDataCatchup(NetworkEntity entity, PlayerID player)
		{
			Grip[] components = base.Components;
			for (int i = 0; i < components.Length; i++)
			{
				OnEntityDataCatchup(components[i], entity, player);
			}
		}

		private static void OnEntityDataCatchup(Grip grip, NetworkEntity entity, PlayerID player)
		{
			NetworkPlayer networkPlayer = LocalPlayer.GetNetworkPlayer();
			if (networkPlayer == null)
			{
				return;
			}
			Enumerator<Hand> enumerator = grip.attachedHands.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Hand hand = enumerator.Current;
				if ((Object)(object)hand == (Object)null || !hand.manager.IsLocalPlayer())
				{
					continue;
				}
				networkPlayer.NetworkEntity.HookOnDataCatchup(player, delegate
				{
					if (!((Object)(object)hand.AttachedReceiver != (Object)(object)grip))
					{
						GrabHelper.SendObjectAttach(hand, grip, player);
					}
				});
			}
		}
	}
	public class GunExtender : EntityComponentArrayExtender<Gun>
	{
		public static readonly FusionComponentCache<Gun, NetworkEntity> Cache = new FusionComponentCache<Gun, NetworkEntity>();

		protected override void OnRegister(NetworkEntity entity, Gun[] components)
		{
			foreach (Gun source in components)
			{
				Cache.Add(source, entity);
			}
		}

		protected override void OnUnregister(NetworkEntity entity, Gun[] components)
		{
			foreach (Gun source in components)
			{
				Cache.Remove(source);
			}
		}
	}
	public class InteractableHostExtender : EntityComponentArrayExtender<InteractableHost>
	{
		public static readonly FusionComponentCache<InteractableHost, NetworkEntity> Cache = new FusionComponentCache<InteractableHost, NetworkEntity>();

		protected override void OnRegister(NetworkEntity entity, InteractableHost[] components)
		{
			foreach (InteractableHost source in components)
			{
				Cache.Add(source, entity);
			}
		}

		protected override void OnUnregister(NetworkEntity entity, InteractableHost[] components)
		{
			foreach (InteractableHost source in components)
			{
				Cache.Remove(source);
			}
		}
	}
	public class InventoryAmmoReceiverExtender : EntityComponentExtender<InventoryAmmoReceiver>
	{
		protected override void OnRegister(NetworkEntity entity, InventoryAmmoReceiver component)
		{
		}

		protected override void OnUnregister(NetworkEntity entity, InventoryAmmoReceiver component)
		{
		}
	}
	public class InventorySlotReceiverExtender : EntityComponentArrayExtender<InventorySlotReceiver>
	{
		public static readonly FusionComponentCache<InventorySlotReceiver, NetworkEntity> Cache = new FusionComponentCache<InventorySlotReceiver, NetworkEntity>();

		protected override void OnRegister(NetworkEntity entity, InventorySlotReceiver[] components)
		{
			foreach (InventorySlotReceiver source in components)
			{
				Cache.Add(source, entity);
			}
			entity.OnEntityDataCatchup += OnEntityDataCatchup;
		}

		protected override void OnUnregister(NetworkEntity entity, InventorySlotReceiver[] components)
		{
			foreach (InventorySlotReceiver source in components)
			{
				Cache.Remove(source);
			}
			entity.OnEntityDataCatchup -= OnEntityDataCatchup;
		}

		private void OnEntityDataCatchup(NetworkEntity entity, PlayerID player)
		{
			InventorySlotReceiver[] components = base.Components;
			foreach (InventorySlotReceiver receiver in components)
			{
				OnEntityDataCatchup(receiver, entity, player);
			}
		}

		private void OnEntityDataCatchup(InventorySlotReceiver receiver, NetworkEntity entity, PlayerID player)
		{
			if (!((Object)(object)receiver._slottedWeapon == (Object)null))
			{
				WeaponSlotExtender.Cache.Get(receiver._slottedWeapon)?.HookOnDataCatchup(player, delegate(NetworkEntity weaponEntity, PlayerID playerID)
				{
					OnWeaponSlotCatchup(weaponEntity, receiver, entity, player);
				});
			}
		}

		private void OnWeaponSlotCatchup(NetworkEntity weaponEntity, InventorySlotReceiver receiver, NetworkEntity slotEntity, PlayerID player)
		{
			byte? b = (byte?)GetIndex(receiver);
			if (b.HasValue)
			{
				MessageRelay.RelayModule<InventorySlotInsertMessage, InventorySlotInsertData>(new InventorySlotInsertData
				{
					SlotEntityID = slotEntity.ID,
					SlotIndex = b.Value,
					WeaponID = weaponEntity.ID
				}, new MessageRoute(player.SmallID, NetworkChannel.Reliable));
			}
		}
	}
	public class MagazineExtender : EntityComponentExtender<Magazine>
	{
		public static readonly FusionComponentCache<Magazine, NetworkEntity> Cache = new FusionComponentCache<Magazine, NetworkEntity>();

		private EntityCleaner _cleaner;

		protected override void OnRegister(NetworkEntity entity, Magazine component)
		{
			Cache.Add(component, entity);
			RegisterCleaner();
			entity.OnEntityDataCatchup += OnEntityDataCatchup;
		}

		protected override void OnUnregister(NetworkEntity entity, Magazine component)
		{
			Cache.Remove(component);
			UnregisterCleaner();
			entity.OnEntityDataCatchup -= OnEntityDataCatchup;
		}

		private void RegisterCleaner()
		{
			if (base.NetworkEntity.Source == EntitySource.Player)
			{
				_cleaner = new EntityCleaner();
				_cleaner.Register(base.NetworkEntity, base.Component.interactableHost, ((SpawnEvents)base.Component)._poolee);
			}
		}

		private void UnregisterCleaner()
		{
			if (_cleaner != null)
			{
				_cleaner.Unregister();
				_cleaner = null;
			}
		}

		private void OnEntityDataCatchup(NetworkEntity entity, PlayerID player)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			MessageRelay.RelayModule<MagazineClaimMessage, MagazineClaimData>(new MagazineClaimData
			{
				OwnerID = PlayerIDManager.LocalSmallID,
				EntityID = entity.ID,
				Handedness = (Handedness)0
			}, new MessageRoute(player.SmallID, NetworkChannel.Reliable));
		}
	}
	public class MarrowBodyExtender : EntityComponentArrayExtender<MarrowBody>
	{
		public static readonly FusionComponentCache<MarrowBody, NetworkEntity> Cache = new FusionComponentCache<MarrowBody, NetworkEntity>();

		protected override void OnRegister(NetworkEntity entity, MarrowBody[] components)
		{
			foreach (MarrowBody source in components)
			{
				Cache.Add(source, entity);
			}
		}

		protected override void OnUnregister(NetworkEntity entity, MarrowBody[] components)
		{
			foreach (MarrowBody source in components)
			{
				Cache.Remove(source);
			}
		}
	}
	public class ObjectDestructibleExtender : EntityComponentArrayExtender<ObjectDestructible>
	{
		public static readonly FusionComponentCache<ObjectDestructible, NetworkEntity> Cache = new FusionComponentCache<ObjectDestructible, NetworkEntity>();

		protected override void OnRegister(NetworkEntity entity, ObjectDestructible[] components)
		{
			foreach (ObjectDestructible source in components)
			{
				Cache.Add(source, entity);
			}
			entity.OnEntityDataCatchup += OnEntityDataCatchup;
		}

		protected override void OnUnregister(NetworkEntity entity, ObjectDestructible[] components)
		{
			foreach (ObjectDestructible source in components)
			{
				Cache.Remove(source);
			}
			entity.OnEntityDataCatchup -= OnEntityDataCatchup;
		}

		private void OnEntityDataCatchup(NetworkEntity entity, PlayerID player)
		{
			ObjectDestructible[] components = base.Components;
			foreach (ObjectDestructible destructible in components)
			{
				OnEntityDataCatchup(destructible, entity, player);
			}
		}

		private void OnEntityDataCatchup(ObjectDestructible destructible, NetworkEntity entity, PlayerID player)
		{
			if (IsDestroyed(destructible))
			{
				MessageRelay.RelayModule<ObjectDestructibleDestroyMessage, ComponentIndexData>(ComponentIndexData.Create(entity.ID, GetIndex(destructible).Value), new MessageRoute(player.SmallID, NetworkChannel.Reliable));
			}
		}

		private static bool IsDestroyed(ObjectDestructible destructible)
		{
			if (destructible._isDead)
			{
				return true;
			}
			Poolee poolee = ((SpawnEvents)destructible)._poolee;
			if ((Object)(object)poolee != (Object)null && poolee.IsInPool && ((SpawnEvents)destructible).IsDespawned)
			{
				return true;
			}
			return false;
		}
	}
	public class PhysLimbExtender : EntityComponentArrayExtender<PhysLimb>
	{
		public static readonly FusionComponentCache<PhysLimb, NetworkEntity> Cache = new FusionComponentCache<PhysLimb, NetworkEntity>();

		protected override void OnRegister(NetworkEntity networkEntity, PhysLimb[] components)
		{
			foreach (PhysLimb source in components)
			{
				Cache.Add(source, networkEntity);
			}
		}

		protected override void OnUnregister(NetworkEntity networkEntity, PhysLimb[] components)
		{
			foreach (PhysLimb source in components)
			{
				Cache.Remove(source);
			}
		}
	}
	public class PooleeExtender : EntityComponentParentExtender<Poolee>
	{
		public static readonly FusionComponentCache<Poolee, NetworkEntity> Cache = new FusionComponentCache<Poolee, NetworkEntity>();

		protected override void OnRegister(NetworkEntity entity, Poolee component)
		{
			Cache.Add(component, entity);
		}

		protected override void OnUnregister(NetworkEntity entity, Poolee component)
		{
			Cache.Remove(component);
		}
	}
	public class PuppetMasterExtender : EntityComponentExtender<PuppetMaster>
	{
		public static readonly FusionComponentCache<PuppetMaster, NetworkEntity> Cache = new FusionComponentCache<PuppetMaster, NetworkEntity>();

		public static NetworkEntity LastKilled { get; set; } = null;


		public bool DefaultUpdateJointAnchors { get; set; } = true;


		protected override void OnRegister(NetworkEntity entity, PuppetMaster component)
		{
			Cache.Add(component, entity);
			DefaultUpdateJointAnchors = component.updateJointAnchors;
			entity.OnEntityOwnershipTransfer = (NetworkEntityPlayerDelegate)Delegate.Combine(entity.OnEntityOwnershipTransfer, new NetworkEntityPlayerDelegate(OnEntityOwnershipTransfer));
			entity.OnEntityDataCatchup += OnEntityDataCatchup;
			if (entity.HasOwner)
			{
				OnEntityOwnershipTransfer(entity, entity.OwnerID);
			}
		}

		protected override void OnUnregister(NetworkEntity entity, PuppetMaster component)
		{
			Cache.Remove(component);
			entity.OnEntityOwnershipTransfer = (NetworkEntityPlayerDelegate)Delegate.Remove(entity.OnEntityOwnershipTransfer, new NetworkEntityPlayerDelegate(OnEntityOwnershipTransfer));
			entity.OnEntityDataCatchup -= OnEntityDataCatchup;
			if ((Object)(object)component != (Object)null)
			{
				RestoreWeights(component);
			}
		}

		private void OnEntityOwnershipTransfer(NetworkEntity entity, PlayerID player)
		{
			if (entity.IsOwner)
			{
				RestoreWeights(base.Component);
			}
			else
			{
				RemoveWeights(base.Component);
			}
		}

		private void RestoreWeights(PuppetMaster puppetMaster)
		{
			puppetMaster.updateJointAnchors = DefaultUpdateJointAnchors;
			puppetMaster.muscleSpring = puppetMaster._defaultMuscleSpring;
			puppetMaster.muscleDamper = puppetMaster._defaultMuscleDamper;
		}

		private void RemoveWeights(PuppetMaster puppetMaster)
		{
			puppetMaster.updateJointAnchors = false;
			puppetMaster.muscleSpring = 0f;
			puppetMaster.muscleDamper = 0f;
		}

		private void OnEntityDataCatchup(NetworkEntity entity, PlayerID player)
		{
			if (base.Component.isDead)
			{
				MessageRelay.RelayModule<PuppetMasterKillMessage, NetworkEntityReference>(new NetworkEntityReference(entity), new MessageRoute(player.SmallID, NetworkChannel.Reliable));
			}
		}
	}
	public class SeatExtender : EntityComponentArrayExtender<Seat>
	{
		public static readonly FusionComponentCache<Seat, NetworkEntity> Cache = new FusionComponentCache<Seat, NetworkEntity>();

		protected override void OnRegister(NetworkEntity entity, Seat[] components)
		{
			foreach (Seat source in components)
			{
				Cache.Add(source, entity);
			}
			entity.OnEntityDataCatchup += OnEntityDataCatchup;
		}

		protected override void OnUnregister(NetworkEntity entity, Seat[] components)
		{
			foreach (Seat source in components)
			{
				Cache.Remove(source);
			}
			entity.OnEntityDataCatchup -= OnEntityDataCatchup;
		}

		private void OnEntityDataCatchup(NetworkEntity entity, PlayerID player)
		{
			Seat[] components = base.Components;
			foreach (Seat seat in components)
			{
				OnEntityDataCatchup(seat, entity, player);
			}
		}

		private void OnEntityDataCatchup(Seat seat, NetworkEntity entity, PlayerID player)
		{
			if (!((Object)(object)seat.rigManager == (Object)null) && NetworkPlayerManager.TryGetPlayer(seat.rigManager, out var _))
			{
				MessageRelay.RelayNative(new PlayerRepSeatData
				{
					SeatID = entity.ID,
					SeatIndex = (byte)GetIndex(seat).Value,
					IsIngress = true
				}, NativeMessageTag.PlayerRepSeat, new MessageRoute(player.SmallID, NetworkChannel.Reliable));
			}
		}
	}
	public class WeaponSlotExtender : EntityComponentExtender<WeaponSlot>
	{
		public static readonly FusionComponentCache<WeaponSlot, NetworkEntity> Cache = new FusionComponentCache<WeaponSlot, NetworkEntity>();

		protected override void OnRegister(NetworkEntity entity, WeaponSlot component)
		{
			Cache.Add(component, entity);
		}

		protected override void OnUnregister(NetworkEntity entity, WeaponSlot component)
		{
			Cache.Remove(component);
		}
	}
	public class EntityCleaner
	{
		private Action<InteractableHost, Hand> _onHandAttached;

		private Action<InteractableHost, Hand> _onHandDetached;

		private int _handCount;

		public TimedDespawner Despawner { get; set; }

		public InteractableHost Host { get; set; }

		public bool Registered { get; set; }

		public NetworkEntity NetworkEntity { get; set; }

		public void Register(NetworkEntity networkEntity, InteractableHost host, Poolee poolee)
		{
			if (!Registered && !((Object)(object)poolee == (Object)null))
			{
				NetworkEntity = networkEntity;
				Host = host;
				RegisterGrips(host);
				RegisterDespawner(poolee);
				Registered = true;
			}
		}

		public void Unregister()
		{
			if (Registered)
			{
				UnregisterGrips(Host);
				UnregisterDespawner();
				NetworkEntity = null;
				Host = null;
				Registered = false;
			}
		}

		private void RegisterGrips(InteractableHost host)
		{
			_onHandAttached = Action<InteractableHost, Hand>.op_Implicit((Action<InteractableHost, Hand>)OnHandAttached);
			_onHandDetached = Action<InteractableHost, Hand>.op_Implicit((Action<InteractableHost, Hand>)OnHandDetached);
			host.onHandAttachedDelegate += _onHandAttached;
			host.onHandDetachedDelegate += _onHandDetached;
		}

		private void UnregisterGrips(InteractableHost host)
		{
			host.onHandAttachedDelegate -= _onHandAttached;
			host.onHandDetachedDelegate -= _onHandDetached;
			_onHandAttached = null;
			_onHandDetached = null;
		}

		private void RegisterDespawner(Poolee poolee)
		{
			Despawner = ((Component)poolee).gameObject.AddComponent<TimedDespawner>();
			Despawner.Poolee = poolee;
			Despawner.OnDespawnCheck += OnDespawnCheck;
		}

		private void UnregisterDespawner()
		{
			Despawner.OnDespawnCheck -= OnDespawnCheck;
			Despawner.Poolee = null;
			Object.Destroy((Object)(object)Despawner);
			Despawner = null;
		}

		private bool OnDespawnCheck()
		{
			if (NetworkEntity != null && !NetworkEntity.IsOwner)
			{
				return false;
			}
			MarrowBody marrowBody = Host._marrowBody;
			if (!Object.op_Implicit((Object)(object)marrowBody))
			{
				return false;
			}
			if (!marrowBody.HasRigidbody)
			{
				return false;
			}
			if (marrowBody._rigidbody.isKinematic)
			{
				return false;
			}
			return true;
		}

		private void OnHandAttached(InteractableHost host, Hand hand)
		{
			_handCount = System.Math.Max(_handCount, 0);
			_handCount++;
			ToggleDespawner(enabled: false);
		}

		private void OnHandDetached(InteractableHost host, Hand hand)
		{
			_handCount--;
			_handCount = System.Math.Max(_handCount, 0);
			if (_handCount <= 0)
			{
				ToggleDespawner(enabled: true);
			}
		}

		private void ToggleDespawner(bool enabled)
		{
			((Behaviour)Despawner).enabled = enabled;
			Despawner.RefreshTimer();
		}
	}
	public class NetworkConstraint : IEntityExtender
	{
		public static readonly FusionComponentCache<ConstraintTracker, NetworkEntity> Cache = new FusionComponentCache<ConstraintTracker, NetworkEntity>();

		private NetworkEntity _networkEntity;

		private ConstraintTracker _tracker;

		private DestroySensor _destroySensor;

		public NetworkEntity NetworkEntity => _networkEntity;

		public ConstraintTracker Tracker => _tracker;

		public bool IsFirst { get; set; }

		public ConstrainerPointPair PointPair { get; set; }

		public ushort OtherId { get; set; }

		public NetworkConstraint(NetworkEntity networkEntity, ConstraintTracker tracker)
		{
			_networkEntity = networkEntity;
			_tracker = tracker;
			networkEntity.HookOnRegistered(OnConstraintRegistered);
			networkEntity.OnEntityUnregistered += OnConstraintUnregistered;
		}

		private void OnConstraintRegistered(NetworkEntity entity)
		{
			entity.ConnectExtender(this);
			entity.OnEntityCreationCatchup += OnEntityCreationCatchup;
			Cache.Add(Tracker, NetworkEntity);
			AddDestroySensor();
		}

		private void OnConstraintUnregistered(NetworkEntity entity)
		{
			entity.DisconnectExtender(this);
			entity.OnEntityCreationCatchup -= OnEntityCreationCatchup;
			if ((Object)(object)Tracker != (Object)null)
			{
				Cache.Remove(Tracker);
			}
			RemoveDestroySensor();
			_tracker = null;
			_networkEntity = null;
		}

		private void OnEntityCreationCatchup(NetworkEntity entity, PlayerID player)
		{
			if (IsFirst)
			{
				ConstraintCreateData constraintCreateData = ConstraintCreateData.Create(PlayerIDManager.LocalSmallID, null, PointPair);
				constraintCreateData.Point1Id = NetworkEntity.ID;
				constraintCreateData.Point2Id = OtherId;
				MessageRelay.RelayModule<ConstraintCreateMessage, ConstraintCreateData>(constraintCreateData, new MessageRoute(player.SmallID, NetworkChannel.Reliable));
			}
		}

		private void AddDestroySensor()
		{
			_destroySensor = ((Component)Tracker).gameObject.AddComponent<DestroySensor>();
			_destroySensor.Hook(OnSensorDestroyed);
		}

		private void RemoveDestroySensor()
		{
			if ((Object)(object)_destroySensor != (Object)null)
			{
				Object.Destroy((Object)(object)_destroySensor);
			}
		}

		private void OnSensorDestroyed()
		{
			if (NetworkEntity != null && NetworkEntity.IsRegistered)
			{
				NetworkEntityManager.IDManager.UnregisterEntity(NetworkEntity);
			}
			_destroySensor = null;
		}
	}
}
namespace LabFusion.Marrow.Combat
{
	public static class NetworkGunManager
	{
		private static AmmoInventory _networkAmmoInventory;

		public static AmmoInventory NetworkAmmoInventory => _networkAmmoInventory;

		public static void OnMainSceneInitialized()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			AmmoInventory instance = AmmoInventory.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				FusionLogger.Warn("Not creating network AmmoInventory since the singleton AmmoInventory is null!");
				return;
			}
			GameObject val = new GameObject("Network AmmoInventory");
			val.SetActive(false);
			_networkAmmoInventory = val.AddComponent<AmmoInventory>();
			_networkAmmoInventory.lightAmmoGroup = instance.lightAmmoGroup;
			_networkAmmoInventory.mediumAmmoGroup = instance.mediumAmmoGroup;
			_networkAmmoInventory.heavyAmmoGroup = instance.heavyAmmoGroup;
			int num = 10000000;
			_networkAmmoInventory.AddCartridge(_networkAmmoInventory.lightAmmoGroup, num);
			_networkAmmoInventory.AddCartridge(_networkAmmoInventory.heavyAmmoGroup, num);
			_networkAmmoInventory.AddCartridge(_networkAmmoInventory.mediumAmmoGroup, num);
			val.SetActive(true);
		}
	}
}
namespace LabFusion.Marrow.Circuits
{
	public static class CircuitHelper
	{
		public static NetworkEntity GetNetworkEntity(Circuit circuit)
		{
			if ((Object)(object)circuit == (Object)null)
			{
				return null;
			}
			ExternalCircuit val = ((Il2CppObjectBase)circuit).TryCast<ExternalCircuit>();
			if ((Object)(object)val != (Object)null && CircuitSocketExtender.ExternalCache.TryGet(val, out var value))
			{
				return CircuitSocketExtender.Cache.Get(value);
			}
			return null;
		}
	}
}
namespace LabFusion.Marrow.Proxies
{
	[RegisterTypeInIl2Cpp]
	public class Keyboard : MonoBehaviour
	{
		public Action<string> OnValueChanged;

		public Action OnOpen;

		public Action OnClose;

		public Action OnEnter;

		private string _value = string.Empty;

		private bool _opened;

		private bool _uppercase;

		private bool _temporaryUppercase;

		private KeyboardButton[] _buttons;

		private TMP_Text _textField;

		public string Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
				UpdateSettings();
				OnValueChanged?.Invoke(value);
			}
		}

		public bool Opened => _opened;

		public bool TemporaryUppercase
		{
			get
			{
				return _temporaryUppercase;
			}
			set
			{
				_temporaryUppercase = value;
			}
		}

		public bool Uppercase
		{
			get
			{
				return _uppercase;
			}
			set
			{
				_uppercase = value;
				KeyboardButton[] buttons = _buttons;
				foreach (KeyboardButton keyboardButton in buttons)
				{
					if (!_temporaryUppercase && keyboardButton.Special)
					{
						keyboardButton.Uppercase = false;
					}
					else
					{
						keyboardButton.Uppercase = value;
					}
				}
			}
		}

		public Keyboard(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			_textField = ((Component)((Component)this).transform.Find("label_TextField/text")).GetComponent<TMP_Text>();
			_buttons = Il2CppArrayBase<KeyboardButton>.op_Implicit(((Component)this).GetComponentsInChildren<KeyboardButton>(true));
			KeyboardButton[] buttons = _buttons;
			for (int i = 0; i < buttons.Length; i++)
			{
				buttons[i].OnPressed += OnKeyPressed;
			}
			UpdateSettings();
		}

		private void OnKeyPressed(string value)
		{
			Value += value;
			if (_temporaryUppercase && Uppercase)
			{
				Uppercase = false;
			}
		}

		public void UpdateSettings()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(Value))
			{
				((Graphic)_textField).color = Color.gray;
				_textField.text = "Enter text...";
			}
			else
			{
				((Graphic)_textField).color = Color.white;
				_textField.text = Value;
			}
		}

		public void Space()
		{
			Value += " ";
		}

		public void Open()
		{
			_opened = true;
			OnOpen?.Invoke();
		}

		public void Close()
		{
			_opened = false;
			OnClose?.Invoke();
		}

		public void Backspace()
		{
			if (Value.Length > 0)
			{
				string value = Value;
				Value = value.Substring(0, value.Length - 1);
			}
		}

		public void Shift()
		{
			Uppercase = (_temporaryUppercase = !Uppercase);
		}

		public void Caps()
		{
			_temporaryUppercase = false;
			Uppercase = !Uppercase;
		}

		public void Enter()
		{
			OnEnter?.Invoke();
			Close();
		}

		public void Copy()
		{
			GUIUtility.systemCopyBuffer = Value;
		}

		public void Paste()
		{
			string systemCopyBuffer = GUIUtility.systemCopyBuffer;
			if (!string.IsNullOrWhiteSpace(systemCopyBuffer))
			{
				Value += systemCopyBuffer;
			}
		}

		public void Clear()
		{
			Value = string.Empty;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class KeyboardButton : MonoBehaviour
	{
		private string _lowercaseKey;

		private string _uppercaseKey;

		private bool _uppercase;

		private TMP_Text _keyText;

		public bool Special { get; set; }

		public bool Uppercase
		{
			get
			{
				return _uppercase;
			}
			set
			{
				_uppercase = value;
				UpdateSettings();
			}
		}

		public string Key
		{
			get
			{
				if (_uppercase && !string.IsNullOrWhiteSpace(_uppercaseKey))
				{
					return _uppercaseKey;
				}
				return _lowercaseKey;
			}
		}

		[HideFromIl2Cpp]
		public event Action<string> OnPressed;

		public KeyboardButton(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			_keyText = ((Component)((Component)this).transform.Find("text")).GetComponent<TMP_Text>();
			Transform val = ((Component)this).transform.Find("Key Variables");
			if ((Object)(object)val != (Object)null)
			{
				_lowercaseKey = ((Object)val.GetChild(0)).name;
				if (val.childCount > 1)
				{
					_uppercaseKey = ((Object)val.GetChild(1)).name;
				}
			}
			if ((Object)(object)val.Find("Special") != (Object)null)
			{
				Special = true;
			}
			UpdateSettings();
		}

		public void UpdateSettings()
		{
			_keyText.text = Key;
		}

		public void Press()
		{
			this.OnPressed?.Invoke(Key);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class AchievementBoard : MonoBehaviour
	{
		public AchievementBoard(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			CupBoardHelper.CompleteAchievementBoard(((Component)this).gameObject);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class BitMart : MonoBehaviour
	{
		public const float PowerTransitionLength = 0.5f;

		private bool _hasElements;

		private bool _turnedOn;

		private float _startMusicPitch;

		private bool _powerTransitioning;

		private float _powerTransitionElapsed;

		public BitMartElement BitMartElement { get; set; }

		public Rigidbody DoorRigidbody { get; set; }

		public Transform ItemSpawnPoint { get; set; }

		public AudioSource MusicSource { get; set; }

		public static event Action<BitMart, PointItem> ItemPurchased;

		public BitMart(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			GetElements();
			AddInteraction();
			FusionSceneManager.HookOnLevelLoad(OnLevelLoad);
			MusicSource.Pause();
			MusicSource.pitch = 0f;
			TurnOff();
		}

		private void AddInteraction()
		{
			PersistentAssetCreator.HookOnSoftGrabLoaded(delegate(HandPose pose)
			{
				foreach (Collider componentsInChild in ((Component)((Component)this).transform.Find("Art")).GetComponentsInChildren<Collider>())
				{
					if ((!Object.op_Implicit((Object)(object)componentsInChild.attachedRigidbody) || componentsInChild.attachedRigidbody.isKinematic) && !Object.op_Implicit((Object)(object)Grip.Cache.Get(((Component)componentsInChild).gameObject)))
					{
						GenericGrip obj = ((Component)componentsInChild).gameObject.AddComponent<GenericGrip>();
						((Grip)obj).isThrowable = true;
						((Grip)obj).ignoreGripTargetOnAttach = false;
						((Grip)obj).additionalGripColliders = Il2CppReferenceArray<Collider>.op_Implicit((Collider[])(object)new Collider[0]);
						((Grip)obj).handleAmplifyCurve = AnimationCurve.Linear(0f, 1f, 0f, 1f);
						((Grip)obj).gripOptions = (InteractionOptions)1;
						((Grip)obj).priority = 1f;
						((Grip)obj).handPose = pose;
						((Grip)obj).minBreakForce = float.PositiveInfinity;
						((Grip)obj).maxBreakForce = float.PositiveInfinity;
						((Grip)obj).defaultGripDistance = float.PositiveInfinity;
						((Grip)obj).radius = 0.24f;
					}
				}
			});
		}

		private void OnLevelLoad()
		{
			MenuButtonHelper.PopulateTexts(((Component)this).gameObject);
			MenuButtonHelper.PopulateButtons(((Component)this).gameObject);
			MusicSource.outputAudioMixerGroup = Audio3dManager.diegeticMusic;
		}

		private void Update()
		{
			if (_powerTransitioning)
			{
				UpdatePowerTransition();
			}
		}

		private void UpdatePowerTransition()
		{
			float num = (_turnedOn ? 1f : 0f);
			_powerTransitionElapsed += Time.deltaTime;
			if (_powerTransitionElapsed >= 0.5f)
			{
				_powerTransitioning = false;
				MusicSource.pitch = num;
				if (!_turnedOn)
				{
					MusicSource.Pause();
				}
			}
			else
			{
				float t = _powerTransitionElapsed / 0.5f;
				MusicSource.pitch = ManagedMathf.Lerp(_startMusicPitch, num, t);
			}
		}

		public void GetElements()
		{
			if (!_hasElements)
			{
				BitMartElement = ((Component)this).GetComponentInChildren<BitMartElement>();
				BitMartElement.GetElements();
				BitMartElement.CatalogElement.OnItemPurchased += OnItemPurchased;
				BitMartElement.CatalogElement.OnItemEquipped += OnItemEquipped;
				BitMartElement.CatalogElement.OnItemUnequipped += OnItemUnequipped;
				BitMartElement.CatalogElement.OnAllItemsUnequipped += OnAllItemsUnequipped;
				DoorRigidbody = ((Component)((Component)this).transform.Find("Art/Offset/VendorAtlas/Door Pivot")).GetComponent<Rigidbody>();
				MusicSource = ((Component)((Component)this).transform.Find("Logic/Music")).GetComponent<AudioSource>();
				ItemSpawnPoint = ((Component)this).transform.Find("Logic/Item Spawn Point");
				_hasElements = true;
			}
		}

		public void TurnOn()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			((Component)BitMartElement).gameObject.SetActive(true);
			if (!_turnedOn)
			{
				LocalAudioPlayer.PlayAtPoint(new AudioReference(FusionMonoDiscReferences.UITurnOnReference), ((Component)BitMartElement).transform.position, LocalAudioPlayer.SFXSettings);
				_turnedOn = true;
				_powerTransitioning = true;
				MusicSource.UnPause();
				if (!MusicSource.isPlaying)
				{
					MusicSource.Play();
				}
			}
			_startMusicPitch = MusicSource.pitch;
			_powerTransitionElapsed = 0f;
		}

		public void TurnOff()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			((Component)BitMartElement).gameObject.SetActive(false);
			if (_turnedOn)
			{
				LocalAudioPlayer.PlayAtPoint(new AudioReference(FusionMonoDiscReferences.UITurnOffReference), ((Component)BitMartElement).transform.position, LocalAudioPlayer.SFXSettings);
				_turnedOn = false;
				_powerTransitioning = true;
			}
			_startMusicPitch = MusicSource.pitch;
			_powerTransitionElapsed = 0f;
		}

		[HideFromIl2Cpp]
		private void OnItemPurchased(PointItem item)
		{
			PushDoor(100f);
			BitMart.ItemPurchased?.InvokeSafe(this, item, "invoking ItemPurchased hook");
		}

		[HideFromIl2Cpp]
		private void OnItemEquipped(PointItem item)
		{
			PushDoor();
		}

		[HideFromIl2Cpp]
		private void OnItemUnequipped(PointItem item)
		{
			PushDoor();
		}

		[HideFromIl2Cpp]
		private void OnAllItemsUnequipped()
		{
			PushDoor();
		}

		private void PushDoor(float force = 10f)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			DoorRigidbody.AddRelativeTorque(Vector3Extensions.left * force, (ForceMode)1);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class InfoBoard : MonoBehaviour
	{
		public InfoBoard(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			InfoBoxHelper.CompleteInfoBoard(((Component)this).gameObject);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class BitCatalogElement : MenuElement
	{
		public enum CatalogTab
		{
			Shop,
			Inventory
		}

		private List<PointItem> _pointItems;

		private List<string> _pallets;

		private Dictionary<string, List<PointItem>> _palletToPointItem;

		private string _currentPallet;

		private PointItem _currentItem;

		private SortMode _sortMode;

		private CatalogTab _catalogTab;

		private bool _hasElements;

		public MenuPage CatalogPage { get; set; }

		public MenuPage BrowserPage { get; set; }

		public MenuPage BitPalletsPage { get; set; }

		[HideFromIl2Cpp]
		public FunctionElement[] BitPalletElements { get; set; }

		public MenuPage BitResultsPage { get; set; }

		[HideFromIl2Cpp]
		public BitResultElement[] BitResultElements { get; set; }

		public PageArrowsElement PageArrowsElement { get; set; }

		public FunctionElement ShopElement { get; set; }

		public FunctionElement InventoryElement { get; set; }

		public MenuPage ItemPage { get; set; }

		public RawImage ItemPreview { get; set; }

		public LabelElement ItemAuthorLabel { get; set; }

		public LabelElement ItemVersionLabel { get; set; }

		public LabelElement ItemTagsLabel { get; set; }

		public FunctionElement ItemToggleElement { get; set; }

		public LabelElement ItemNameLabel { get; set; }

		public LabelElement ItemDescriptionLabel { get; set; }

		public LabelElement ItemPriceLabel { get; set; }

		public FunctionElement ItemBuyElement { get; set; }

		public FunctionElement ItemCloseElement { get; set; }

		public LabelElement ItemTitleLabel { get; set; }

		public FunctionElement CatalogCloseElement { get; set; }

		public FunctionElement CatalogSortByElement { get; set; }

		public FunctionElement CatalogUnequipAllElement { get; set; }

		public TMP_Text CatalogBitCountText { get; set; }

		[HideFromIl2Cpp]
		public event Action<PointItem> OnItemPurchased;

		[HideFromIl2Cpp]
		public event Action<PointItem> OnItemEquipped;

		[HideFromIl2Cpp]
		public event Action<PointItem> OnItemUnequipped;

		[HideFromIl2Cpp]
		public event Action OnAllItemsUnequipped;

		public BitCatalogElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			GetElements();
			PointItemManager.OnBitCountChanged += OnBitCountChanged;
		}

		protected override void OnDestroy()
		{
			base.OnDestroy();
			PointItemManager.OnBitCountChanged -= OnBitCountChanged;
		}

		private void OnBitCountChanged()
		{
			DrawBitCount();
		}

		public void GetElements()
		{
			if (!_hasElements)
			{
				CatalogPage = ((Component)this).GetComponent<MenuPage>();
				BrowserPage = ((Component)((Component)this).transform.Find("panel_Browser")).GetComponent<MenuPage>();
				BitPalletsPage = ((Component)((Component)BrowserPage).transform.Find("panel_BitPallets")).GetComponent<MenuPage>();
				BitPalletElements = Il2CppArrayBase<FunctionElement>.op_Implicit(((Component)BitPalletsPage).GetComponentsInChildren<FunctionElement>(true));
				PopulateBitPalletElements();
				BitResultsPage = ((Component)((Component)BrowserPage).transform.Find("panel_BitResults")).GetComponent<MenuPage>();
				BitResultElements = Il2CppArrayBase<BitResultElement>.op_Implicit(((Component)BitResultsPage).GetComponentsInChildren<BitResultElement>(true));
				PopulateBitResultElements();
				Transform val = ((Component)BrowserPage).transform.Find("group_Toolbars");
				PageArrowsElement = ((Component)val.Find("button_PageArrows")).GetComponent<PageArrowsElement>();
				PageArrowsElement.OnPageIndexChanged += OnPageIndexChanged;
				Transform val2 = val.Find("layout_Tabs");
				ShopElement = ((Component)val2.Find("button_Shop")).GetComponent<FunctionElement>().WithTitle("Shop").Do(SelectShopTab);
				InventoryElement = ((Component)val2.Find("button_Inventory")).GetComponent<FunctionElement>().WithTitle("Inventory").Do(SelectInventoryTab);
				ItemPage = ((Component)((Component)this).transform.Find("panel_BitItem")).GetComponent<MenuPage>();
				Transform obj = ((Component)ItemPage).transform.Find("layout_Information");
				Transform val3 = obj.Find("layout_Preview");
				ItemPreview = ((Component)val3.Find("icon_Preview/image_Preview")).GetComponent<RawImage>();
				ItemAuthorLabel = ((Component)val3.Find("label_Author")).GetComponent<LabelElement>();
				ItemVersionLabel = ((Component)val3.Find("label_Version")).GetComponent<LabelElement>();
				ItemTagsLabel = ((Component)val3.Find("label_Tags")).GetComponent<LabelElement>();
				ItemToggleElement = ((Component)val3.Find("button_Toggle")).GetComponent<FunctionElement>().Do(ToggleItem);
				Transform val4 = obj.Find("layout_Description");
				ItemNameLabel = ((Component)val4.Find("label_Name")).GetComponent<LabelElement>();
				ItemDescriptionLabel = ((Component)val4.Find("label_Description")).GetComponent<LabelElement>();
				ItemPriceLabel = ((Component)val4.Find("label_Price")).GetComponent<LabelElement>();
				ItemBuyElement = ((Component)val4.Find("button_Buy")).GetComponent<FunctionElement>().Do(ConfirmPurchase);
				ItemCloseElement = ((Component)((Component)ItemPage).transform.Find("group_Toolbar/button_Close")).GetComponent<FunctionElement>().Do(GoToBitResults);
				ItemTitleLabel = ((Component)((Component)ItemPage).transform.Find("group_Toolbar/label_Title")).GetComponent<LabelElement>().WithTitle("INFORMATION");
				Transform val5 = ((Component)this).transform.Find("layout_Options");
				CatalogCloseElement = ((Component)val5.Find("button_Close")).GetComponent<FunctionElement>().Do(delegate
				{
					CatalogPage.Parent.SelectSubPage(CatalogPage.DefaultPageIndex);
				});
				CatalogSortByElement = ((Component)val5.Find("button_SortBy")).GetComponent<FunctionElement>().WithTitle($"Sort By: {_sortMode}").Do(NextSortMode);
				CatalogUnequipAllElement = ((Component)val5.Find("button_UnequipAll")).GetComponent<FunctionElement>().WithTitle("Unequip All").Do(UnequipAll);
				CatalogBitCountText = ((Component)val5.Find("label_BitCount/text")).GetComponent<TMP_Text>();
				_hasElements = true;
			}
		}

		private void NextSortMode()
		{
			_sortMode++;
			if (_sortMode >= SortMode.LAST_SORT)
			{
				_sortMode = SortMode.PRICE;
			}
			CatalogSortByElement.Title = $"Sort By: {_sortMode}";
			Draw();
		}

		private void SelectShopTab()
		{
			_catalogTab = CatalogTab.Shop;
			PageArrowsElement.PageIndex = 0;
			GoToBitPallets();
		}

		private void SelectInventoryTab()
		{
			_catalogTab = CatalogTab.Inventory;
			PageArrowsElement.PageIndex = 0;
			GoToBitPallets();
		}

		private void UnequipAll()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			PointItemManager.UnequipAll();
			this.OnAllItemsUnequipped?.Invoke();
			LocalAudioPlayer.PlayAtPoint(new AudioReference(FusionMonoDiscReferences.UnequipItemReference), ((Component)this).transform.position, LocalAudioPlayer.SFXSettings);
			Draw();
			DrawPointItem();
		}

		private void ConfirmPurchase()
		{
			if (!_currentItem.IsUnlocked)
			{
				TryBuyItem();
			}
			else if (!_currentItem.IsMaxUpgrade)
			{
				TryUpgradeItem();
			}
		}

		private void GoToBitPallets()
		{
			CatalogPage.SelectSubPage(BrowserPage);
			BrowserPage.SelectSubPage(BitPalletsPage);
			Draw();
		}

		private void GoToBitResults()
		{
			CatalogPage.SelectSubPage(BrowserPage);
			BrowserPage.SelectSubPage(BitResultsPage);
			Draw();
		}

		private void TryBuyItem()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (PointItemManager.TryBuyItem(_currentItem))
			{
				this.OnItemPurchased?.Invoke(_currentItem);
				GoToBitResults();
				LocalAudioPlayer.PlayAtPoint(new AudioReference(FusionMonoDiscReferences.SuccessfulPurchaseReference), ((Component)this).transform.position, LocalAudioPlayer.SFXSettings);
			}
			else
			{
				LocalAudioPlayer.PlayAtPoint(new AudioReference(FusionMonoDiscReferences.FailedPurchaseReference), ((Component)this).transform.position, LocalAudioPlayer.SFXSettings);
			}
		}

		private void TryUpgradeItem()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (PointItemManager.TryUpgradeItem(_currentItem))
			{
				GoToBitResults();
				LocalAudioPlayer.PlayAtPoint(new AudioReference(FusionMonoDiscReferences.SuccessfulPurchaseReference), ((Component)this).transform.position, LocalAudioPlayer.SFXSettings);
			}
			else
			{
				LocalAudioPlayer.PlayAtPoint(new AudioReference(FusionMonoDiscReferences.FailedPurchaseReference), ((Component)this).transform.position, LocalAudioPlayer.SFXSettings);
			}
		}

		private void ToggleItem()
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (_currentItem.IsUnlocked)
			{
				if (_currentItem.IsEquipped)
				{
					this.OnItemUnequipped?.Invoke(_currentItem);
					PointItemManager.SetEquipped(_currentItem, isEquipped: false);
					LocalAudioPlayer.PlayAtPoint(new AudioReference(FusionMonoDiscReferences.UnequipItemReference), ((Component)this).transform.position, LocalAudioPlayer.SFXSettings);
				}
				else
				{
					this.OnItemEquipped?.Invoke(_currentItem);
					PointItemManager.SetEquipped(_currentItem, isEquipped: true);
					LocalAudioPlayer.PlayAtPoint(new AudioReference(FusionMonoDiscReferences.EquipItemReference), ((Component)this).transform.position, LocalAudioPlayer.SFXSettings);
				}
				DrawPointItem();
			}
		}

		private void OnPageIndexChanged(int index)
		{
			Draw();
		}

		[HideFromIl2Cpp]
		public void ShowPointItem(PointItem pointItem)
		{
			_currentItem = pointItem;
			CatalogPage.SelectSubPage(ItemPage);
			DrawPointItem();
		}

		private void DrawPointItem()
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			PointItem currentItem = _currentItem;
			if (currentItem == null)
			{
				return;
			}
			currentItem.LoadPreviewIcon(delegate(Texture2D texture)
			{
				if (!((Object)(object)ItemPreview == (Object)null))
				{
					ItemPreview.texture = (Texture)(object)texture;
				}
			});
			ItemAuthorLabel.Title = currentItem.Author;
			ItemVersionLabel.Title = currentItem.Version;
			if (currentItem.Tags != null && currentItem.Tags.Length != 0)
			{
				string text = currentItem.Tags[0];
				for (int i = 1; i < currentItem.Tags.Length; i++)
				{
					text = text + ", " + currentItem.Tags[i];
				}
				ItemTagsLabel.Title = text;
			}
			else
			{
				ItemTagsLabel.Title = "Misc";
			}
			ItemNameLabel.Title = currentItem.Title;
			ItemNameLabel.Color = PointItemManager.ParseColor(currentItem.Rarity);
			ItemDescriptionLabel.Title = currentItem.CurrentDescription;
			ItemPriceLabel.Title = PointItemManager.ParsePrice(currentItem.CurrentPrice, currentItem.IsMaxUpgrade && currentItem.IsUnlocked);
			ItemBuyElement.Interactable = true;
			if (currentItem.IsUnlocked)
			{
				if (!currentItem.HasUpgrades)
				{
					((Component)ItemBuyElement).gameObject.SetActive(false);
				}
				else if (currentItem.IsMaxUpgrade)
				{
					ItemBuyElement.Interactable = false;
					ItemBuyElement.Title = $"Max Level {currentItem.UpgradeCount}";
				}
				else
				{
					((Component)ItemBuyElement).gameObject.SetActive(true);
					ItemBuyElement.Title = $"Upgrade To Level {currentItem.CurrentUpgradeIndex + 2}/{currentItem.UpgradeCount}";
				}
			}
			else
			{
				((Component)ItemBuyElement).gameObject.SetActive(currentItem.CurrentPrice < 1000000);
				ItemBuyElement.Title = "Buy";
			}
			((Component)ItemToggleElement).gameObject.SetActive(currentItem.IsUnlocked && currentItem.Equippable);
			if (currentItem.IsEquipped)
			{
				ItemToggleElement.Title = "Unequip";
			}
			else
			{
				ItemToggleElement.Title = "Equip";
			}
		}

		[HideFromIl2Cpp]
		public void ShowPointItems(List<PointItem> pointItems)
		{
			_pointItems = pointItems;
			_palletToPointItem = new Dictionary<string, List<PointItem>>();
			_pallets = new List<string>();
			foreach (PointItem pointItem in pointItems)
			{
				string category = pointItem.Category;
				if (!_pallets.Contains(category))
				{
					_pallets.Add(category);
				}
				if (!_palletToPointItem.ContainsKey(category))
				{
					_palletToPointItem[category] = new List<PointItem>();
				}
				_palletToPointItem[category].Add(pointItem);
			}
			_pallets = (from x in _pallets
				orderby x
				orderby !x.StartsWith("Fusion")
				select x).ToList();
		}

		protected override void OnDraw()
		{
			if (_catalogTab == CatalogTab.Shop)
			{
				IReadOnlyList<PointItem> lockedItems = PointItemManager.GetLockedItems(_sortMode);
				ShowPointItems(lockedItems.ToList());
			}
			else
			{
				IReadOnlyList<PointItem> unlockedItems = PointItemManager.GetUnlockedItems(_sortMode);
				ShowPointItems(unlockedItems.ToList());
			}
			DrawBitCount();
			if (((Behaviour)BitPalletsPage).isActiveAndEnabled)
			{
				PageArrowsElement.PageCount = GetBitPalletsPageCount();
				DrawBitPallets(PageArrowsElement.PageIndex);
			}
			if (((Behaviour)BitResultsPage).isActiveAndEnabled)
			{
				PageArrowsElement.PageCount = GetBitResultsPageCount();
				DrawBitResults(PageArrowsElement.PageIndex);
			}
		}

		private int GetBitPalletsPageCount()
		{
			if (_pallets == null)
			{
				return 0;
			}
			return (int)Mathf.Ceil((float)_pallets.Count / (float)BitPalletElements.Length);
		}

		private int GetBitResultsPageCount()
		{
			if (string.IsNullOrWhiteSpace(_currentPallet) || !_palletToPointItem.ContainsKey(_currentPallet))
			{
				return 0;
			}
			return (int)Mathf.Ceil((float)_palletToPointItem[_currentPallet].Count / (float)BitResultElements.Length);
		}

		private void PopulateBitPalletElements()
		{
			for (int i = 0; i < BitPalletElements.Length; i++)
			{
				int index = i;
				BitPalletElements[i].Do(delegate
				{
					SelectBitPallet(index);
				});
			}
		}

		private void PopulateBitResultElements()
		{
			for (int i = 0; i < BitResultElements.Length; i++)
			{
				int index = i;
				BitResultElements[i].OnPressed = delegate
				{
					SelectBitResult(index);
				};
			}
		}

		private void SelectBitPallet(int index)
		{
			if (_pallets != null)
			{
				int num = index + PageArrowsElement.PageIndex * BitPalletElements.Length;
				if (num < _pallets.Count)
				{
					_currentPallet = _pallets[num];
					BrowserPage.SelectSubPage(BitResultsPage);
					PageArrowsElement.PageIndex = 0;
				}
			}
		}

		private void SelectBitResult(int index)
		{
			if (_pointItems != null && _currentPallet != null)
			{
				List<PointItem> list = _palletToPointItem[_currentPallet];
				int num = index + PageArrowsElement.PageIndex * BitResultElements.Length;
				if (num < list.Count)
				{
					PointItem pointItem = list[num];
					ShowPointItem(pointItem);
				}
			}
		}

		private void DrawBitCount()
		{
			CatalogBitCountText.text = $"{PointItemManager.GetBitCount()}";
		}

		private void DrawBitPallets(int page)
		{
			FunctionElement[] bitPalletElements = BitPalletElements;
			for (int i = 0; i < bitPalletElements.Length; i++)
			{
				((Component)bitPalletElements[i]).gameObject.SetActive(false);
			}
			if (_pallets != null)
			{
				int num = BitPalletElements.Length;
				int num2 = page * num;
				for (int j = 0; j < num && j + num2 < _pallets.Count; j++)
				{
					BitPalletElements[j].Title = _pallets[j + num2];
					((Component)BitPalletElements[j]).gameObject.SetActive(true);
				}
			}
		}

		private void DrawBitResults(int page)
		{
			BitResultElement[] bitResultElements = BitResultElements;
			for (int i = 0; i < bitResultElements.Length; i++)
			{
				((Component)bitResultElements[i]).gameObject.SetActive(false);
			}
			if (_pointItems != null && _currentPallet != null && _palletToPointItem.ContainsKey(_currentPallet))
			{
				List<PointItem> list = _palletToPointItem[_currentPallet];
				int num = BitResultElements.Length;
				int num2 = page * num;
				for (int j = 0; j < num && j + num2 < list.Count; j++)
				{
					BitResultElements[j].ApplyPointItem(list[j + num2]);
					((Component)BitResultElements[j]).gameObject.SetActive(true);
				}
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public class BitMartElement : MenuElement
	{
		private bool _hasElements;

		public MenuPage BitMartPage { get; set; }

		public BitWelcomeElement WelcomeElement { get; set; }

		public BitCatalogElement CatalogElement { get; set; }

		public MenuPage BitDownloadPage { get; set; }

		public FunctionElement BitDownloadYesElement { get; set; }

		public FunctionElement BitDownloadNoElement { get; set; }

		public BitMartElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			GetElements();
		}

		public void GetElements()
		{
			if (!_hasElements)
			{
				BitMartPage = ((Component)this).GetComponent<MenuPage>();
				WelcomeElement = ((Component)((Component)this).transform.Find("panel_BitWelcome")).GetComponent<BitWelcomeElement>();
				WelcomeElement.GetElements();
				WelcomeElement.ViewShopElement.Do(delegate
				{
					BitMartPage.SelectSubPage(CatalogElement.CatalogPage);
				});
				WelcomeElement.DownloadCosmeticsElement.Do(delegate
				{
					BitMartPage.SelectSubPage(BitDownloadPage);
				});
				CatalogElement = ((Component)((Component)this).transform.Find("panel_BitCatalog")).GetComponent<BitCatalogElement>();
				CatalogElement.GetElements();
				BitDownloadPage = ((Component)((Component)this).transform.Find("panel_BitDownload")).GetComponent<MenuPage>();
				BitDownloadYesElement = ((Component)((Component)BitDownloadPage).transform.Find("layout_Options/button_Yes")).GetComponent<FunctionElement>().Do(delegate
				{
					DownloadOfficialCosmetics();
					BitMartPage.SelectSubPage(WelcomeElement.WelcomePage);
				});
				BitDownloadNoElement = ((Component)((Component)BitDownloadPage).transform.Find("layout_Options/button_No")).GetComponent<FunctionElement>().Do(delegate
				{
					BitMartPage.SelectSubPage(WelcomeElement.WelcomePage);
				});
				_hasElements = true;
			}
		}

		private static void DownloadOfficialCosmetics()
		{
			ModIODownloader.EnqueueDownload(new ModTransaction
			{
				ModFile = new ModIOFile(4106245),
				Callback = delegate(DownloadCallbackInfo info)
				{
					if (info.Result != ModResult.SUCCEEDED)
					{
						Notifier.Send(new Notification
						{
							Title = "Download Failed",
							Message = "Failed to download Fusion Cosmetics!",
							SaveToMenu = false,
							ShowPopup = true,
							Type = NotificationType.ERROR
						});
					}
				}
			});
		}
	}
	[RegisterTypeInIl2Cpp]
	public class BitResultElement : MenuElement
	{
		private Texture _defaultPreview;

		public Action OnPressed;

		private bool _hasReferences;

		public RawImage Preview { get; set; }

		public TMP_Text ItemNameText { get; set; }

		public TMP_Text ItemTagText { get; set; }

		public TMP_Text ItemPriceText { get; set; }

		public BitResultElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void Awake()
		{
			GetReferences();
		}

		public void GetReferences()
		{
			if (!_hasReferences)
			{
				Preview = ((Component)((Component)this).transform.Find("icon_Background/icon_Preview")).GetComponent<RawImage>();
				_defaultPreview = Preview.texture;
				Transform val = ((Component)this).transform.Find("layout_Info");
				ItemNameText = ((Component)val.Find("text_ItemName")).GetComponent<TMP_Text>();
				ItemTagText = ((Component)val.Find("text_ItemTag")).GetComponent<TMP_Text>();
				ItemPriceText = ((Component)val.Find("text_ItemPrice")).GetComponent<TMP_Text>();
				_hasReferences = true;
			}
		}

		public void Press()
		{
			OnPressed?.Invoke();
		}

		[HideFromIl2Cpp]
		public void ApplyPointItem(PointItem item)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			GetReferences();
			ItemNameText.text = item.Title;
			((Graphic)ItemNameText).color = PointItemManager.ParseColor(item.Rarity);
			ItemTagText.text = item.MainTag;
			ItemPriceText.text = PointItemManager.ParsePrice(item.Price, item.IsUnlocked);
			Preview.texture = _defaultPreview;
			item.LoadPreviewIcon(delegate(Texture2D texture)
			{
				if (!((Object)(object)Preview == (Object)null))
				{
					Preview.texture = (Texture)(object)texture;
				}
			});
		}
	}
	[RegisterTypeInIl2Cpp]
	public class BitWelcomeElement : MenuElement
	{
		private bool _hasElements;

		public MenuPage WelcomePage { get; set; }

		public FunctionElement ViewShopElement { get; set; }

		public FunctionElement DownloadCosmeticsElement { get; set; }

		public BitWelcomeElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void Awake()
		{
			GetElements();
		}

		public void GetElements()
		{
			if (!_hasElements)
			{
				WelcomePage = ((Component)this).GetComponent<MenuPage>();
				Transform val = ((Component)this).transform.Find("grid_Options");
				ViewShopElement = ((Component)val.Find("button_ViewShop")).GetComponent<FunctionElement>().WithTitle("View Shop");
				DownloadCosmeticsElement = ((Component)val.Find("button_DownloadCosmetics")).GetComponent<FunctionElement>().WithTitle("Download Official Cosmetics");
				_hasElements = true;
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public class GamemodeResultElement : MenuElement
	{
		public Action OnPressed;

		private bool _hasReferences;

		public TMP_Text GamemodeNameText { get; private set; }

		public GameObject BorderGameObject { get; private set; }

		public RawImage GamemodeIcon { get; private set; }

		public GamemodeResultElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void Awake()
		{
			GetReferences();
		}

		public void Highlight(bool highlighted)
		{
			GetReferences();
			BorderGameObject.SetActive(highlighted);
		}

		public void GetReferences()
		{
			if (!_hasReferences)
			{
				GamemodeNameText = ((Component)((Component)this).transform.Find("text_GamemodeName")).GetComponent<TMP_Text>();
				Transform val = ((Component)this).transform.Find("label_GamemodeIcon");
				GamemodeIcon = ((Component)val.Find("icon_Mask/icon_Gamemode")).GetComponent<RawImage>();
				BorderGameObject = ((Component)val.Find("icon_Border")).gameObject;
				_hasReferences = true;
			}
		}

		public void Press()
		{
			OnPressed?.Invoke();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class LevelResultElement : MenuElement
	{
		public Action OnRemovePressed;

		private bool _hasReferences;

		public TMP_Text LevelNameText { get; private set; }

		public RawImage LevelIcon { get; private set; }

		public LevelResultElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void Awake()
		{
			GetReferences();
		}

		public void GetReferences()
		{
			if (!_hasReferences)
			{
				LevelNameText = ((Component)((Component)this).transform.Find("layout_TopOptions/levelName_Background/text_LevelName")).GetComponent<TMP_Text>();
				LevelIcon = ((Component)((Component)this).transform.Find("icon_Background/icon_Level")).GetComponent<RawImage>();
				_hasReferences = true;
			}
		}

		public void Remove()
		{
			OnRemovePressed?.Invoke();
		}

		[HideFromIl2Cpp]
		public void ApplyLevel(string barcode)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			GetReferences();
			LevelCrate crate = CrateFilterer.GetCrate<LevelCrate>(new Barcode(barcode));
			if ((Object)(object)crate == (Object)null)
			{
				LevelNameText.text = "No Level";
				LevelIcon.texture = MenuResources.GetLevelIcon("Empty");
				return;
			}
			string title = ((Scannable)crate).Title;
			LevelNameText.text = title;
			int modID = CrateFilterer.GetModID(((Crate)crate).Pallet);
			ElementIconHelper.SetLevelIcon(LevelIcon, title, modID);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class LevelRotationResultElement : MenuElement
	{
		public Action OnSelectPressed;

		public Action OnEditPressed;

		private bool _hasReferences;

		public TMP_Text LevelRotationNameText { get; private set; }

		public GameObject BorderGameObject { get; private set; }

		public RawImage LevelIcon { get; private set; }

		public LevelRotationResultElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void Awake()
		{
			GetReferences();
		}

		public void Highlight(bool highlighted)
		{
			GetReferences();
			BorderGameObject.SetActive(highlighted);
		}

		public void GetReferences()
		{
			if (!_hasReferences)
			{
				LevelRotationNameText = ((Component)((Component)this).transform.Find("layout_TopOptions/levelRotationName_Background/text_LevelRotationName")).GetComponent<TMP_Text>();
				LevelIcon = ((Component)((Component)this).transform.Find("icon_Background/icon_Level")).GetComponent<RawImage>();
				BorderGameObject = ((Component)((Component)this).transform.Find("icon_Border")).gameObject;
				_hasReferences = true;
			}
		}

		[HideFromIl2Cpp]
		public void ApplyLevelIcon(string barcode)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			GetReferences();
			if (barcode == null)
			{
				LevelIcon.texture = MenuResources.GetLevelIcon("Empty");
				return;
			}
			LevelCrate crate = CrateFilterer.GetCrate<LevelCrate>(new Barcode(barcode));
			if ((Object)(object)crate == (Object)null)
			{
				LevelIcon.texture = MenuResources.GetLevelIcon("Empty");
				return;
			}
			string title = ((Scannable)crate).Title;
			int modID = CrateFilterer.GetModID(((Crate)crate).Pallet);
			ElementIconHelper.SetLevelIcon(LevelIcon, title, modID);
		}

		public void Select()
		{
			OnSelectPressed?.Invoke();
		}

		public void Edit()
		{
			OnEditPressed?.Invoke();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class BoolElement : ButtonElement
	{
		private bool _value;

		public Action<bool> OnValueChanged;

		private Button _button;

		private GameObject _falseObject;

		private GameObject _trueObject;

		public bool Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
				Draw();
				OnValueChanged?.Invoke(value);
			}
		}

		public BoolElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		protected override void Awake()
		{
			base.Awake();
			_button = ((Component)this).GetComponent<Button>();
			Transform val = ((Component)this).transform.Find("False Object");
			if ((Object)(object)val != (Object)null)
			{
				_falseObject = ((Component)val).gameObject;
			}
			Transform val2 = ((Component)this).transform.Find("True Object");
			if ((Object)(object)val2 != (Object)null)
			{
				_trueObject = ((Component)val2).gameObject;
			}
		}

		public void Toggle()
		{
			Value = !Value;
		}

		public override void UpdateText()
		{
			base.UpdateText();
			if ((Object)(object)_button != (Object)null)
			{
				((Selectable)_button).interactable = base.Interactable;
			}
			if ((Object)(object)_trueObject != (Object)null)
			{
				_trueObject.SetActive(Value);
			}
			if ((Object)(object)_falseObject != (Object)null)
			{
				_falseObject.SetActive(!Value);
			}
		}

		protected override void OnClearValues()
		{
			_value = false;
			OnValueChanged = null;
			base.OnClearValues();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class ButtonElement : LabelElement
	{
		private bool _interactable = true;

		public bool Interactable
		{
			get
			{
				return _interactable;
			}
			set
			{
				_interactable = value;
				Draw();
			}
		}

		public ButtonElement(IntPtr intPtr)
			: base(intPtr)
		{
		}
	}
	[RegisterTypeInIl2Cpp]
	public class DropdownElement : GroupElement
	{
		private bool _expanded;

		private Transform _arrowTransform;

		public bool Expanded => _expanded;

		public DropdownElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		protected override void Awake()
		{
			base.Awake();
			Transform val = ((Component)this).transform.Find("Background/text_Label");
			if ((Object)(object)val != (Object)null)
			{
				base.Text = ((Component)val).GetComponent<TMP_Text>();
			}
			_arrowTransform = ((Component)this).transform.Find("Background/image_Arrow");
		}

		protected override void OnEnable()
		{
			Collapse();
			base.OnEnable();
		}

		public void Toggle()
		{
			if (Expanded)
			{
				Collapse();
			}
			else
			{
				Expand();
			}
		}

		protected override void OnElementAdded(MenuElement element)
		{
			((Component)element).gameObject.SetActive(Expanded);
		}

		public void Expand()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			foreach (MenuElement element in base.Elements)
			{
				((Component)element).gameObject.SetActive(true);
			}
			_expanded = true;
			if ((Object)(object)_arrowTransform != (Object)null)
			{
				_arrowTransform.localRotation = Quaternion.identity;
			}
		}

		public void Collapse()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			foreach (MenuElement element in base.Elements)
			{
				((Component)element).gameObject.SetActive(false);
			}
			_expanded = false;
			if ((Object)(object)_arrowTransform != (Object)null)
			{
				_arrowTransform.localRotation = Quaternion.Euler(0f, 0f, 90f);
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public class EnumElement : ValueElement
	{
		private Enum _value;

		private Type _enumType;

		public Action<Enum> OnValueChanged;

		private int _enumIndex = 1;

		private Array _enumValues;

		[HideFromIl2Cpp]
		public Enum Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
				UpdateEnumIndex();
				Draw();
				OnValueChanged?.Invoke(value);
			}
		}

		[HideFromIl2Cpp]
		public Type EnumType
		{
			get
			{
				return _enumType;
			}
			set
			{
				_enumType = value;
				if (value != null)
				{
					_enumValues = Enum.GetValues(_enumType);
					if (_value == null)
					{
						_value = _enumValues.GetValue(0) as Enum;
					}
					UpdateEnumIndex();
				}
			}
		}

		public EnumElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		[HideFromIl2Cpp]
		public override object GetValue()
		{
			return Value;
		}

		public void NextValue()
		{
			if (_enumValues != null)
			{
				_enumIndex++;
				_enumIndex %= _enumValues.Length;
				Value = _enumValues.GetValue(_enumIndex) as Enum;
			}
		}

		public void PreviousValue()
		{
			if (_enumValues != null)
			{
				_enumIndex--;
				if (_enumIndex < 0)
				{
					_enumIndex = _enumValues.Length - 1;
				}
				_enumIndex %= _enumValues.Length;
				Value = _enumValues.GetValue(_enumIndex) as Enum;
			}
		}

		private void UpdateEnumIndex()
		{
			if (_enumValues == null)
			{
				return;
			}
			for (int i = 0; i < _enumValues.Length; i++)
			{
				if (_enumValues.GetValue(i).ToString() == _value.ToString())
				{
					_enumIndex = i;
					break;
				}
			}
		}

		protected override void OnClearValues()
		{
			_value = null;
			OnValueChanged = null;
			base.OnClearValues();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class FloatElement : ValueElement
	{
		private float _value;

		public Action<float> OnValueChanged;

		public float Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
				Draw();
				OnValueChanged?.Invoke(value);
			}
		}

		public float MinValue { get; set; }

		public float MaxValue { get; set; } = 1f;


		public float Increment { get; set; } = 0.01f;


		public FloatElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void NextValue()
		{
			float num = Value + Increment;
			if (num > MaxValue)
			{
				num = MaxValue;
			}
			Value = num;
		}

		public void PreviousValue()
		{
			float num = Value - Increment;
			if (num < MinValue)
			{
				num = MinValue;
			}
			Value = num;
		}

		[HideFromIl2Cpp]
		public override object GetValue()
		{
			return Mathf.Round(Value * 1000f) / 1000f;
		}

		protected override void OnClearValues()
		{
			_value = 0f;
			MinValue = 0f;
			MaxValue = 1f;
			Increment = 0.01f;
			OnValueChanged = null;
			base.OnClearValues();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class FunctionElement : ButtonElement
	{
		public Action OnPressed;

		private Button _button;

		public FunctionElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		protected override void Awake()
		{
			base.Awake();
			_button = ((Component)this).GetComponent<Button>();
		}

		public void Press()
		{
			OnPressed?.Invoke();
		}

		protected override void OnDraw()
		{
			base.OnDraw();
			if ((Object)(object)_button != (Object)null)
			{
				((Selectable)_button).interactable = base.Interactable;
			}
		}

		protected override void OnClearValues()
		{
			OnPressed = null;
			base.OnClearValues();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class GroupElement : LabelElement
	{
		private readonly List<MenuElement> _elements = new List<MenuElement>();

		private readonly List<MenuElement> _elementTemplates = new List<MenuElement>();

		private bool _hasTemplates;

		[HideFromIl2Cpp]
		public List<MenuElement> Elements => _elements;

		[HideFromIl2Cpp]
		public List<MenuElement> Templates => _elementTemplates;

		public GroupElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		protected override void Awake()
		{
			base.Awake();
			GetTemplates();
		}

		private void GetTemplates()
		{
			if (_hasTemplates)
			{
				return;
			}
			IEnumerator enumerator = ((Component)this).transform.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					MenuElement component = ((Component)((Il2CppObjectBase)enumerator.Current).TryCast<Transform>()).GetComponent<MenuElement>();
					if ((Object)(object)component != (Object)null)
					{
						_elementTemplates.Add(component);
					}
				}
			}
			finally
			{
				if (enumerator is IDisposable disposable)
				{
					disposable.Dispose();
				}
			}
			_hasTemplates = true;
		}

		[HideFromIl2Cpp]
		protected virtual void OnElementAdded(MenuElement element)
		{
			((Component)element).gameObject.SetActive(true);
		}

		[HideFromIl2Cpp]
		protected virtual void OnElementRemoved(MenuElement element)
		{
		}

		[HideFromIl2Cpp]
		public TElement AddElement<TElement>(string title) where TElement : MenuElement
		{
			GetTemplates();
			TElement val = null;
			foreach (MenuElement elementTemplate in _elementTemplates)
			{
				TElement val2 = ((Il2CppObjectBase)elementTemplate).TryCast<TElement>();
				if ((Object)(object)val2 != (Object)null)
				{
					val = val2;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			TElement val3 = Object.Instantiate<TElement>(val, ((Component)this).transform, false);
			((Object)val3).name = title;
			val3.Title = title;
			_elements.Add(val3);
			OnElementAdded(val3);
			return val3;
		}

		[HideFromIl2Cpp]
		public TElement AddOrGetElement<TElement>(string title) where TElement : MenuElement
		{
			foreach (MenuElement element in Elements)
			{
				if (!(element.Title != title))
				{
					TElement val = ((Il2CppObjectBase)element).TryCast<TElement>();
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
				}
			}
			return AddElement<TElement>(title);
		}

		[HideFromIl2Cpp]
		public bool RemoveElement<TElement>(TElement element) where TElement : MenuElement
		{
			if (!Elements.Contains(element))
			{
				return false;
			}
			_elements.Remove(element);
			OnElementRemoved(element);
			Object.Destroy((Object)(object)((Component)element).gameObject);
			return true;
		}

		[HideFromIl2Cpp]
		public int RemoveElements<TElement>() where TElement : MenuElement
		{
			List<TElement> list = new List<TElement>();
			foreach (MenuElement element in Elements)
			{
				TElement val = ((Il2CppObjectBase)element).TryCast<TElement>();
				if (!((Object)(object)val == (Object)null))
				{
					list.Add(val);
				}
			}
			int num = 0;
			foreach (TElement item in list)
			{
				RemoveElement(item);
				num++;
			}
			return num;
		}

		[HideFromIl2Cpp]
		public int RemoveElements()
		{
			return RemoveElements<MenuElement>();
		}

		protected override void OnClearValues()
		{
			RemoveElements();
			base.OnClearValues();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class IntElement : ValueElement
	{
		private int _value;

		public Action<int> OnValueChanged;

		public int Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
				Draw();
				OnValueChanged?.Invoke(value);
			}
		}

		public int MinValue { get; set; }

		public int MaxValue { get; set; } = 1;


		public int Increment { get; set; } = 1;


		public IntElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void NextValue()
		{
			int num = Value + Increment;
			if (num > MaxValue)
			{
				num = MaxValue;
			}
			Value = num;
		}

		public void PreviousValue()
		{
			int num = Value - Increment;
			if (num < MinValue)
			{
				num = MinValue;
			}
			Value = num;
		}

		[HideFromIl2Cpp]
		public override object GetValue()
		{
			return Value;
		}

		protected override void OnClearValues()
		{
			_value = 0;
			MinValue = 0;
			MaxValue = 1;
			Increment = 1;
			OnValueChanged = null;
			base.OnClearValues();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class LabelElement : MenuElement
	{
		private Color _color = Color.white;

		private string _textFormat;

		private TMP_Text _text;

		public Color Color
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _color;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				_color = value;
				Draw();
			}
		}

		public TMP_Text Text
		{
			get
			{
				return _text;
			}
			set
			{
				_text = value;
			}
		}

		public virtual string DefaultTextFormat => "{0}";

		public string TextFormat
		{
			get
			{
				if (string.IsNullOrWhiteSpace(_textFormat))
				{
					_textFormat = DefaultTextFormat;
				}
				return _textFormat;
			}
			set
			{
				_textFormat = value;
				Draw();
			}
		}

		public LabelElement(IntPtr intPtr)
			: base(intPtr)
		{
		}//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)


		protected virtual void Awake()
		{
			Transform val = ((Component)this).transform.Find("text");
			if ((Object)(object)val != (Object)null)
			{
				_text = ((Component)val).GetComponent<TMP_Text>();
			}
		}

		protected override void OnDraw()
		{
			base.OnDraw();
			UpdateText();
		}

		public virtual void UpdateText()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Text != (Object)null)
			{
				Text.text = string.Format(TextFormat, base.Title);
				((Graphic)Text).color = Color;
			}
		}

		protected override void OnClearValues()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			_color = Color.white;
			base.OnClearValues();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class PageArrowsElement : MenuElement
	{
		private int _pageIndex;

		private int _pageCount;

		private bool _hasReferences;

		public FunctionElement BackArrowElement { get; set; }

		public FunctionElement NextArrowElement { get; set; }

		public LabelElement PageCountLabel { get; set; }

		public int PageIndex
		{
			get
			{
				return _pageIndex;
			}
			set
			{
				_pageIndex = ManagedMathf.Clamp(value, 0, PageCount - 1);
				Draw();
				this.OnPageIndexChanged?.Invoke(value);
			}
		}

		public int PageCount
		{
			get
			{
				if (_pageCount <= 0)
				{
					return 1;
				}
				return _pageCount;
			}
			set
			{
				_pageCount = value;
				_pageIndex = ManagedMathf.Clamp(_pageIndex, 0, PageCount - 1);
				Draw();
			}
		}

		[HideFromIl2Cpp]
		public event Action<int> OnPageIndexChanged;

		public PageArrowsElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			GetReferences();
		}

		public void GetReferences()
		{
			if (!_hasReferences)
			{
				BackArrowElement = ((Component)((Component)this).transform.Find("button_BackArrow")).GetComponent<FunctionElement>().Do(PreviousPage);
				NextArrowElement = ((Component)((Component)this).transform.Find("button_NextArrow")).GetComponent<FunctionElement>().Do(NextPage);
				PageCountLabel = ((Component)((Component)this).transform.Find("label_PageCount")).GetComponent<LabelElement>();
				_hasReferences = true;
			}
		}

		public void PreviousPage()
		{
			if (PageIndex > 0)
			{
				PageIndex--;
			}
		}

		public void NextPage()
		{
			if (PageIndex + 1 < PageCount)
			{
				PageIndex++;
			}
		}

		protected override void OnDraw()
		{
			PageCountLabel.Title = $"Page {PageIndex + 1}/{PageCount}";
			((Component)BackArrowElement).gameObject.SetActive(PageIndex > 0);
			((Component)NextArrowElement).gameObject.SetActive(PageIndex + 1 < PageCount);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class PageElement : GroupElement
	{
		private List<PageElement> _pages = new List<PageElement>();

		private PageElement _root;

		[HideFromIl2Cpp]
		public List<PageElement> Pages => _pages;

		[HideFromIl2Cpp]
		public PageElement Root => _root;

		public PageElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			if (Pages.Count > 0)
			{
				SelectPage(Pages[0]);
			}
		}

		protected override void OnElementRemoved(MenuElement element)
		{
			PageElement pageElement = ((Il2CppObjectBase)element).TryCast<PageElement>();
			if ((Object)(object)pageElement != (Object)null && Pages.Contains(pageElement))
			{
				_pages.Remove(pageElement);
			}
			base.OnElementRemoved(element);
		}

		public void Toggle(bool visible)
		{
			((Component)this).gameObject.SetActive(visible);
		}

		public void TogglePages(bool visible)
		{
			foreach (PageElement page in Pages)
			{
				page.Toggle(visible);
			}
		}

		public void Select()
		{
			if ((Object)(object)Root != (Object)null)
			{
				Root.SelectPage(this);
			}
		}

		public void SelectPage(PageElement page)
		{
			if ((Object)(object)Root != (Object)null)
			{
				Root.SelectPage(page);
			}
			else if (Pages.Contains(page))
			{
				TogglePages(visible: false);
				page.Toggle(visible: true);
			}
		}

		public PageElement AddPage(string title)
		{
			if ((Object)(object)Root != (Object)null)
			{
				return Root.AddPage(title);
			}
			bool num = Pages.Count <= 0;
			PageElement pageElement = AddElement<PageElement>(title);
			pageElement._root = this;
			((Component)pageElement).gameObject.SetActive(false);
			_pages.Add(pageElement);
			if (num)
			{
				SelectPage(pageElement);
			}
			return pageElement;
		}

		public PageElement AddPage()
		{
			return AddPage("Page");
		}
	}
	[RegisterTypeInIl2Cpp]
	public class StringElement : ButtonElement
	{
		public Action<string> OnValueChanged;

		public Action OnSubmitted;

		public Action<bool> OnKeyboardToggled;

		private string _value;

		private string _emptyFormat = "Click to add {0}...";

		private Button _button;

		public string Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
				Draw();
				OnValueChanged?.Invoke(value);
			}
		}

		public string EmptyFormat
		{
			get
			{
				return _emptyFormat;
			}
			set
			{
				_emptyFormat = value;
				Draw();
			}
		}

		public override string DefaultTextFormat => "{0}: {1}";

		public StringElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		protected override void Awake()
		{
			base.Awake();
			_button = ((Component)this).GetComponent<Button>();
		}

		protected override void OnDraw()
		{
			base.OnDraw();
			if ((Object)(object)_button != (Object)null)
			{
				((Selectable)_button).interactable = base.Interactable;
			}
		}

		public void Submit()
		{
			OnSubmitted?.Invoke();
		}

		public void ToggleKeyboard()
		{
			if (MenuKeyboardHelper.KeyboardOpened)
			{
				MenuKeyboardHelper.CloseKeyboard();
				OnKeyboardToggled?.Invoke(obj: false);
			}
			else
			{
				MenuKeyboardHelper.AssignKeyboardToButton(this);
				OnKeyboardToggled?.Invoke(obj: true);
			}
		}

		public override void UpdateText()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)base.Text != (Object)null)
			{
				if (string.IsNullOrEmpty(Value))
				{
					base.Text.text = string.Format(EmptyFormat, base.Title.ToLower());
					((Graphic)base.Text).color = Color.gray * base.Color;
				}
				else
				{
					base.Text.text = string.Format(base.TextFormat, base.Title, Value);
					((Graphic)base.Text).color = base.Color;
				}
			}
		}

		protected override void OnClearValues()
		{
			_value = null;
			OnValueChanged = null;
			base.OnClearValues();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class ValueElement : ButtonElement
	{
		private Button _leftArrow;

		private Button _rightArrow;

		public override string DefaultTextFormat => "{0}: {1}";

		public ValueElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		protected override void Awake()
		{
			base.Awake();
			_leftArrow = ((Component)((Component)this).transform.Find("button_LeftArrow")).GetComponent<Button>();
			_rightArrow = ((Component)((Component)this).transform.Find("button_RightArrow")).GetComponent<Button>();
		}

		protected override void OnDraw()
		{
			base.OnDraw();
			if ((Object)(object)_leftArrow != (Object)null)
			{
				((Component)_leftArrow).gameObject.SetActive(base.Interactable);
			}
			if ((Object)(object)_rightArrow != (Object)null)
			{
				((Component)_rightArrow).gameObject.SetActive(base.Interactable);
			}
		}

		public override void UpdateText()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)base.Text != (Object)null)
			{
				base.Text.text = string.Format(base.TextFormat, base.Title, GetValue());
				((Graphic)base.Text).color = base.Color;
			}
		}

		[HideFromIl2Cpp]
		public virtual object GetValue()
		{
			return null;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class LobbyElement : MenuElement
	{
		private bool _interactable = true;

		private bool _hasElements;

		public bool Interactable
		{
			get
			{
				return _interactable;
			}
			set
			{
				_interactable = value;
				Draw();
			}
		}

		public RawImage LevelIcon { get; set; }

		public RawImage GamemodeIcon { get; private set; }

		public MenuPage LobbyPage { get; set; }

		public LabelElement LevelNameElement { get; set; }

		public LabelElement ServerVersionElement { get; set; }

		public IntElement PlayersElement { get; set; }

		public FunctionElement ServerActionElement { get; set; }

		public FunctionElement MoreElement { get; set; }

		public EnumElement PrivacyElement { get; set; }

		public StringElement ServerNameElement { get; set; }

		public LabelElement HostNameElement { get; set; }

		public StringElement DescriptionElement { get; set; }

		public PageElement SettingsElement { get; set; }

		public GameObject BansGrid { get; set; }

		public PageElement BansElement { get; set; }

		public GameObject AdminGrid { get; set; }

		public PageElement AdminElement { get; set; }

		public GameObject CodeGrid { get; set; }

		public StringElement CodeElement { get; set; }

		public FunctionElement CodeRefreshElement { get; set; }

		public PageElement PlayerBrowserElement { get; set; }

		public PlayerElement ProfileElement { get; set; }

		public LobbyElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void Awake()
		{
			GetElements();
		}

		public void GetElements()
		{
			if (!_hasElements)
			{
				LobbyPage = ((Component)this).GetComponent<MenuPage>();
				Transform obj = ((Component)this).transform.Find("panel_Main");
				Transform val = obj.Find("grid_LevelInfo");
				Transform val2 = val.Find("background_Level");
				LevelIcon = ((Component)val2.Find("icon_Level")).GetComponent<RawImage>();
				GamemodeIcon = ((Component)val2.Find("icon_Gamemode")).GetComponent<RawImage>();
				LevelNameElement = ((Component)val.Find("label_LevelName")).GetComponent<LabelElement>();
				ServerVersionElement = ((Component)val.Find("label_ServerVersion")).GetComponent<LabelElement>();
				PlayersElement = ((Component)val.Find("button_Players")).GetComponent<IntElement>();
				PrivacyElement = ((Component)val.Find("button_Privacy")).GetComponent<EnumElement>();
				ServerActionElement = ((Component)val.Find("button_ServerAction")).GetComponent<FunctionElement>();
				MoreElement = ((Component)val.Find("button_More")).GetComponent<FunctionElement>();
				Transform val3 = obj.Find("grid_ServerInfo");
				ServerNameElement = ((Component)val3.Find("button_ServerName")).GetComponent<StringElement>();
				HostNameElement = ((Component)val3.Find("label_HostName")).GetComponent<LabelElement>();
				DescriptionElement = ((Component)val3.Find("button_Description")).GetComponent<StringElement>();
				PlayerBrowserElement = ((Component)val3.Find("scrollRect_PlayerBrowser/Viewport/Content")).GetComponent<PageElement>();
				Transform val4 = val3.Find("grid_Code");
				CodeGrid = ((Component)val4).gameObject;
				CodeElement = ((Component)val4.Find("button_Code")).GetComponent<StringElement>();
				CodeRefreshElement = ((Component)val4.Find("button_Refresh")).GetComponent<FunctionElement>();
				Transform obj2 = ((Component)this).transform.Find("panel_More");
				Transform obj3 = obj2.Find("grid_Groups");
				Transform val5 = obj3.Find("grid_Settings");
				SettingsElement = ((Component)val5.Find("scrollRect_Settings/Viewport/Content")).GetComponent<PageElement>();
				Transform val6 = obj3.Find("grid_Bans");
				BansGrid = ((Component)val6).gameObject;
				BansElement = ((Component)val6.Find("scrollRect_Bans/Viewport/Content")).GetComponent<PageElement>();
				Transform val7 = obj2.Find("grid_Admin");
				AdminGrid = ((Component)val7).gameObject;
				AdminElement = ((Component)val7.Find("scrollRect_Admin/Viewport/Content")).GetComponent<PageElement>();
				Transform val8 = ((Component)this).transform.Find("panel_Profile");
				ProfileElement = ((Component)val8).GetComponent<PlayerElement>();
				_hasElements = true;
			}
		}

		protected override void OnDraw()
		{
			base.OnDraw();
			if ((Object)(object)PlayersElement != (Object)null)
			{
				PlayersElement.Interactable = Interactable;
			}
			if ((Object)(object)PrivacyElement != (Object)null)
			{
				PrivacyElement.Interactable = Interactable;
			}
			if ((Object)(object)ServerNameElement != (Object)null)
			{
				ServerNameElement.Interactable = Interactable;
			}
			if ((Object)(object)DescriptionElement != (Object)null)
			{
				DescriptionElement.Interactable = Interactable;
			}
			if ((Object)(object)ProfileElement != (Object)null)
			{
				ProfileElement.Interactable = Interactable;
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public class LobbyResultElement : MenuElement
	{
		public Action OnPressed;

		private bool _hasReferences;

		public TMP_Text LevelNameText { get; private set; }

		public TMP_Text ServerNameText { get; private set; }

		public TMP_Text HostNameText { get; private set; }

		public TMP_Text PlayerCountText { get; private set; }

		public TMP_Text VersionText { get; private set; }

		public RawImage LevelIcon { get; private set; }

		public RawImage GamemodeIcon { get; private set; }

		public LobbyResultElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void Awake()
		{
			GetReferences();
		}

		public void GetReferences()
		{
			if (!_hasReferences)
			{
				Transform val = ((Component)this).transform.Find("levelName_Background");
				LevelNameText = ((Component)val.Find("text_LevelName")).GetComponent<TMP_Text>();
				Transform val2 = ((Component)this).transform.Find("icon_Background");
				LevelIcon = ((Component)val2.Find("icon_Level")).GetComponent<RawImage>();
				GamemodeIcon = ((Component)val2.Find("icon_Gamemode")).GetComponent<RawImage>();
				Transform val3 = ((Component)this).transform.Find("layout_Info");
				ServerNameText = ((Component)val3.Find("text_ServerName")).GetComponent<TMP_Text>();
				HostNameText = ((Component)val3.Find("text_HostName")).GetComponent<TMP_Text>();
				PlayerCountText = ((Component)val3.Find("text_PlayerCount")).GetComponent<TMP_Text>();
				VersionText = ((Component)val3.Find("text_Version")).GetComponent<TMP_Text>();
				_hasReferences = true;
			}
		}

		public void Press()
		{
			OnPressed?.Invoke();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class PlayerElement : MenuElement
	{
		private bool _interactable = true;

		private bool _hasElements;

		public bool Interactable
		{
			get
			{
				return _interactable;
			}
			set
			{
				_interactable = value;
				Draw();
			}
		}

		public MenuPage PlayerPage { get; set; }

		public RawImage PlayerIcon { get; set; }

		public AspectRatioFitter PlayerIconFitter { get; set; }

		public GameObject OptionsGameObject { get; set; }

		public PageElement OptionsElement { get; set; }

		public FloatElement VolumeElement { get; set; }

		public EnumElement PermissionsElement { get; set; }

		public StringElement PlatformIDElement { get; set; }

		public LabelElement UsernameElement { get; set; }

		public StringElement NicknameElement { get; set; }

		public StringElement DescriptionElement { get; set; }

		public GameObject ActionsGrid { get; set; }

		public PageElement ActionsElement { get; set; }

		public PlayerElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void Awake()
		{
			GetElements();
		}

		public void GetElements()
		{
			if (!_hasElements)
			{
				PlayerPage = ((Component)this).GetComponent<MenuPage>();
				Transform obj = ((Component)this).transform.Find("panel_Main");
				Transform val = obj.Find("grid_PlayerOptions");
				PlayerIcon = ((Component)val.Find("label_ProfileIcon/icon_Mask/icon_Player")).GetComponent<RawImage>();
				PlayerIconFitter = ((Component)PlayerIcon).GetComponent<AspectRatioFitter>();
				OptionsGameObject = ((Component)val.Find("scrollRect_ProfileOptions")).gameObject;
				OptionsElement = ((Component)OptionsGameObject.transform.Find("Viewport/Content")).GetComponent<PageElement>();
				PageElement pageElement = OptionsElement.AddPage("Options");
				VolumeElement = pageElement.AddElement<FloatElement>("Volume");
				PermissionsElement = pageElement.AddElement<EnumElement>("Permissions");
				PlatformIDElement = pageElement.AddElement<StringElement>("Platform ID").WithInteractability(interactable: false);
				PlatformIDElement.EmptyFormat = "No Platform ID";
				Transform val2 = obj.Find("grid_PlayerInfo");
				UsernameElement = ((Component)val2.Find("label_Username")).GetComponent<LabelElement>();
				NicknameElement = ((Component)val2.Find("button_Nickname")).GetComponent<StringElement>();
				DescriptionElement = ((Component)val2.Find("button_Description")).GetComponent<StringElement>();
				Transform val3 = val2.Find("grid_Actions");
				ActionsGrid = ((Component)val3).gameObject;
				ActionsElement = ((Component)val3.Find("scrollRect_Actions/Viewport/Content")).GetComponent<PageElement>();
				_hasElements = true;
			}
		}

		protected override void OnDraw()
		{
			base.OnDraw();
			if ((Object)(object)NicknameElement != (Object)null)
			{
				NicknameElement.Interactable = Interactable;
			}
			if ((Object)(object)DescriptionElement != (Object)null)
			{
				DescriptionElement.Interactable = Interactable;
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public class PlayerResultElement : MenuElement
	{
		public Action OnPressed;

		private bool _hasReferences;

		public TMP_Text PlayerNameText { get; private set; }

		public TMP_Text RoleText { get; private set; }

		public RawImage PlayerIcon { get; private set; }

		public AspectRatioFitter PlayerIconFitter { get; set; }

		public RawImage PlayerStatus { get; private set; }

		public RawImage PlayerBorder { get; private set; }

		public PlayerResultElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void Awake()
		{
			GetReferences();
		}

		public void GetReferences()
		{
			if (!_hasReferences)
			{
				Transform val = ((Component)this).transform.Find("label_ProfileIcon");
				PlayerIcon = ((Component)val.Find("icon_Mask/icon_Player")).GetComponent<RawImage>();
				PlayerIconFitter = ((Component)PlayerIcon).GetComponent<AspectRatioFitter>();
				PlayerStatus = ((Component)val.Find("icon_StatusDrop/icon_Status")).GetComponent<RawImage>();
				PlayerBorder = ((Component)val.Find("border")).GetComponent<RawImage>();
				Transform val2 = ((Component)this).transform.Find("layout_Info");
				PlayerNameText = ((Component)val2.Find("text_PlayerName")).GetComponent<TMP_Text>();
				RoleText = ((Component)val2.Find("text_Role")).GetComponent<TMP_Text>();
				_hasReferences = true;
			}
		}

		public void Press()
		{
			OnPressed?.Invoke();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class MenuElement : MonoBehaviour
	{
		private string _title = "Element";

		public string Title
		{
			get
			{
				return _title;
			}
			set
			{
				_title = value;
				Draw();
			}
		}

		[HideFromIl2Cpp]
		public event Action OnCleared;

		public MenuElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		protected virtual void OnEnable()
		{
			Draw();
		}

		protected virtual void OnDestroy()
		{
			Clear();
		}

		public void Clear()
		{
			OnClearValues();
			this.OnCleared?.Invoke();
			this.OnCleared = null;
		}

		protected virtual void OnClearValues()
		{
			_title = "Element";
		}

		public void Draw()
		{
			OnDraw();
		}

		protected virtual void OnDraw()
		{
		}
	}
	[RegisterTypeInIl2Cpp]
	public class NotificationElement : MenuElement
	{
		public Action OnAccepted;

		public Action OnDeclined;

		private bool _hasReferences;

		public TMP_Text TitleText { get; set; }

		public TMP_Text MessageText { get; set; }

		public GameObject AcceptButton { get; set; }

		public GameObject DeclineButton { get; set; }

		public NotificationElement(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void Awake()
		{
			GetReferences();
		}

		public void GetReferences()
		{
			if (!_hasReferences)
			{
				Transform val = ((Component)this).transform.Find("layout_Info");
				TitleText = ((Component)val.Find("text_Title")).GetComponent<TMP_Text>();
				MessageText = ((Component)val.Find("text_Message")).GetComponent<TMP_Text>();
				Transform val2 = ((Component)this).transform.Find("layout_Options");
				AcceptButton = ((Component)val2.Find("button_Accept")).gameObject;
				DeclineButton = ((Component)val2.Find("button_Decline")).gameObject;
				_hasReferences = true;
			}
		}

		public void Accept()
		{
			OnAccepted?.Invoke();
		}

		public void Decline()
		{
			OnDeclined?.Invoke();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class LevelNameLabel : MonoBehaviour
	{
		private TMP_Text _text;

		public LevelNameLabel(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			_text = ((Component)this).GetComponentInChildren<TMP_Text>();
			_text.text = FusionSceneManager.Title;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class MenuPage : MonoBehaviour
	{
		public Action OnShown;

		public Action OnEnabled;

		public Action OnDisabled;

		private List<MenuPage> _subPages;

		private MenuPage _rootCurrentPage;

		public MenuPage CurrentPage { get; set; }

		[HideFromIl2Cpp]
		public List<MenuPage> SubPages => _subPages;

		public int DefaultPageIndex { get; set; }

		public MenuPage Parent { get; set; }

		public MenuPage Root
		{
			get
			{
				if ((Object)(object)Parent == (Object)null)
				{
					return this;
				}
				return Parent.Root;
			}
		}

		public MenuPage RootCurrentPage => Root._rootCurrentPage;

		public MenuPage(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			GetSubPages();
			if ((Object)(object)Parent == (Object)null && (Object)(object)((Component)this).transform.parent != (Object)null)
			{
				Parent = ((Component)((Component)this).transform.parent).GetComponentInParent<MenuPage>();
			}
		}

		private void GetSubPages()
		{
			_subPages = new List<MenuPage>();
			IEnumerator enumerator = ((Component)this).transform.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					MenuPage component = ((Component)((Il2CppObjectBase)enumerator.Current).TryCast<Transform>()).GetComponent<MenuPage>();
					if (!((Object)(object)component == (Object)null))
					{
						_subPages.Add(component);
						component.Parent = this;
					}
				}
			}
			finally
			{
				if (enumerator is IDisposable disposable)
				{
					disposable.Dispose();
				}
			}
		}

		private void ResetPages()
		{
			HideSubPages();
			SelectSubPage(DefaultPageIndex);
		}

		private void OnEnable()
		{
			ResetPages();
			OnEnabled?.Invoke();
		}

		private void OnDisable()
		{
			OnDisabled?.Invoke();
		}

		public void ShowPage()
		{
			((Component)this).gameObject.SetActive(true);
			OnShown?.Invoke();
		}

		public void HidePage()
		{
			((Component)this).gameObject.SetActive(false);
		}

		public void HideSubPages()
		{
			foreach (MenuPage subPage in _subPages)
			{
				subPage.HidePage();
			}
		}

		[HideFromIl2Cpp]
		public void SelectSubPage(MenuPage page)
		{
			if ((Object)(object)CurrentPage != (Object)null)
			{
				CurrentPage.HidePage();
				CurrentPage = null;
			}
			CurrentPage = page;
			CurrentPage.ShowPage();
			Root._rootCurrentPage = page;
		}

		public void SelectSubPage(int index)
		{
			if (_subPages != null && _subPages.Count > 0 && _subPages.Count > index)
			{
				SelectSubPage(_subPages[index]);
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public class MenuPopups : MonoBehaviour
	{
		private MenuToolbar _toolbar;

		private Keyboard _keyboard;

		public MenuToolbar Toolbar => _toolbar;

		public Keyboard Keyboard => _keyboard;

		public MenuPopups(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			_toolbar = ((Component)this).GetComponentInChildren<MenuToolbar>(true);
			_keyboard = ((Component)this).GetComponentInChildren<Keyboard>(true);
			Keyboard keyboard = _keyboard;
			keyboard.OnOpen = (Action)Delegate.Combine(keyboard.OnOpen, new Action(OnKeyboardOpen));
			Keyboard keyboard2 = _keyboard;
			keyboard2.OnClose = (Action)Delegate.Combine(keyboard2.OnClose, new Action(OnKeyboardClose));
		}

		private void OnEnable()
		{
			_keyboard.Close();
		}

		private void OnKeyboardOpen()
		{
			((Component)_keyboard).gameObject.SetActive(true);
			((Component)_toolbar).gameObject.SetActive(false);
		}

		private void OnKeyboardClose()
		{
			((Component)_keyboard).gameObject.SetActive(false);
			((Component)_toolbar).gameObject.SetActive(true);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class MenuToolbar : MonoBehaviour
	{
		public MenuToolbar(IntPtr intPtr)
			: base(intPtr)
		{
		}
	}
	[RegisterTypeInIl2Cpp]
	public class ScrollButtonProxy : MonoBehaviour
	{
		public ScrollButtonProxy(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			ScrollButton val = ((Component)this).gameObject.AddComponent<ScrollButton>();
			if (((Object)((Component)this).transform).name.ToLower().Contains("down"))
			{
				val.direction = (ScrollButtonDirection)1;
			}
			else
			{
				val.direction = (ScrollButtonDirection)0;
			}
			val.button = ((Component)this).GetComponent<Button>();
			val.incremental = true;
			val.scrollFrequency = 1f;
			val.signedStepSize = 0.65f;
			val.stepSize = 0.65f;
			Transform val2 = ((Component)((Component)this).GetComponentInParent<ScrollRect>()).transform.Find("Viewport/Content");
			ScrollElementsContainer val3 = ((Component)val2).GetComponent<ScrollElementsContainer>();
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = ((Component)val2).gameObject.AddComponent<ScrollElementsContainer>();
			}
			val.scrollElementsContainer = val3;
			val.scrollbar = ((Component)((Component)this).transform.parent).GetComponentInChildren<Scrollbar>();
		}
	}
	[RegisterTypeInIl2Cpp]
	public class LevelDownloadUI : MonoBehaviour
	{
		private bool _hasReferences;

		public static LevelDownloadUI Instance { get; private set; }

		public TMP_Text LevelTitleText { get; set; }

		public Slider ProgressBarSlider { get; set; }

		public TMP_Text ProgressBarText { get; set; }

		public RawImage LevelIcon { get; set; }

		public LevelDownloadUI(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			Instance = this;
			GetReferences();
		}

		private void GetReferences()
		{
			if (!_hasReferences)
			{
				LevelTitleText = ((Component)((Component)this).transform.Find("Downloading/Level Name")).GetComponent<TMP_Text>();
				ProgressBarSlider = ((Component)((Component)this).transform.Find("Downloading/Progress Bar")).GetComponent<Slider>();
				ProgressBarText = ((Component)((Component)ProgressBarSlider).transform.Find("text")).GetComponent<TMP_Text>();
				LevelIcon = ((Component)((Component)this).transform.Find("Level Icon")).GetComponent<RawImage>();
				_hasReferences = true;
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public class UIPanel : MonoBehaviour
	{
		public UIPanel(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			UIMachineUtilities.CreateLaserCursor(((Component)this).transform.parent, ((Component)this).transform, ((Component)this).transform.localScale);
		}
	}
}
namespace LiteNetLib
{
	internal abstract class BaseChannel
	{
		protected readonly NetPeer Peer;

		protected readonly Queue<NetPacket> OutgoingQueue = new Queue<NetPacket>(64);

		private int _isAddedToPeerChannelSendQueue;

		public int PacketsInQueue => OutgoingQueue.Count;

		protected BaseChannel(NetPeer peer)
		{
			Peer = peer;
		}

		public void AddToQueue(NetPacket packet)
		{
			lock (OutgoingQueue)
			{
				OutgoingQueue.Enqueue(packet);
			}
			AddToPeerChannelSendQueue();
		}

		protected void AddToPeerChannelSendQueue()
		{
			if (Interlocked.CompareExchange(ref _isAddedToPeerChannelSendQueue, 1, 0) == 0)
			{
				Peer.AddToReliableChannelSendQueue(this);
			}
		}

		public bool SendAndCheckQueue()
		{
			bool num = SendNextPackets();
			if (!num)
			{
				Interlocked.Exchange(ref _isAddedToPeerChannelSendQueue, 0);
			}
			return num;
		}

		protected abstract bool SendNextPackets();

		public abstract bool ProcessPacket(NetPacket packet);
	}
	internal enum ConnectionRequestResult
	{
		None,
		Accept,
		Reject,
		RejectForce
	}
	public class ConnectionRequest
	{
		private readonly NetManager _listener;

		private int _used;

		internal NetConnectRequestPacket InternalPacket;

		public readonly IPEndPoint RemoteEndPoint;

		public NetDataReader Data => InternalPacket.Data;

		internal ConnectionRequestResult Result { get; private set; }

		internal void UpdateRequest(NetConnectRequestPacket connectRequest)
		{
			if (connectRequest.ConnectionTime >= InternalPacket.ConnectionTime && (connectRequest.ConnectionTime != InternalPacket.ConnectionTime || connectRequest.ConnectionNumber != InternalPacket.ConnectionNumber))
			{
				InternalPacket = connectRequest;
			}
		}

		private bool TryActivate()
		{
			return Interlocked.CompareExchange(ref _used, 1, 0) == 0;
		}

		internal ConnectionRequest(IPEndPoint remoteEndPoint, NetConnectRequestPacket requestPacket, NetManager listener)
		{
			InternalPacket = requestPacket;
			RemoteEndPoint = remoteEndPoint;
			_listener = listener;
		}

		public NetPeer AcceptIfKey(string key)
		{
			if (!TryActivate())
			{
				return null;
			}
			try
			{
				if (Data.GetString() == key)
				{
					Result = ConnectionRequestResult.Accept;
				}
			}
			catch
			{
				NetDebug.WriteError("[AC] Invalid incoming data");
			}
			if (Result == ConnectionRequestResult.Accept)
			{
				return _listener.OnConnectionSolved(this, null, 0, 0);
			}
			Result = ConnectionRequestResult.Reject;
			_listener.OnConnectionSolved(this, null, 0, 0);
			return null;
		}

		public NetPeer Accept()
		{
			if (!TryActivate())
			{
				return null;
			}
			Result = ConnectionRequestResult.Accept;
			return _listener.OnConnectionSolved(this, null, 0, 0);
		}

		public void Reject(byte[] rejectData, int start, int length, bool force)
		{
			if (TryActivate())
			{
				Result = (force ? ConnectionRequestResult.RejectForce : ConnectionRequestResult.Reject);
				_listener.OnConnectionSolved(this, rejectData, start, length);
			}
		}

		public void Reject(byte[] rejectData, int start, int length)
		{
			Reject(rejectData, start, length, force: false);
		}

		public void RejectForce(byte[] rejectData, int start, int length)
		{
			Reject(rejectData, start, length, force: true);
		}

		public void RejectForce()
		{
			Reject(null, 0, 0, force: true);
		}

		public void RejectForce(byte[] rejectData)
		{
			Reject(rejectData, 0, rejectData.Length, force: true);
		}

		public void RejectForce(NetDataWriter rejectData)
		{
			Reject(rejectData.Data, 0, rejectData.Length, force: true);
		}

		public void Reject()
		{
			Reject(null, 0, 0, force: false);
		}

		public void Reject(byte[] rejectData)
		{
			Reject(rejectData, 0, rejectData.Length, force: false);
		}

		public void Reject(NetDataWriter rejectData)
		{
			Reject(rejectData.Data, 0, rejectData.Length, force: false);
		}
	}
	public enum UnconnectedMessageType
	{
		BasicMessage,
		Broadcast
	}
	public enum DisconnectReason
	{
		ConnectionFailed,
		Timeout,
		HostUnreachable,
		NetworkUnreachable,
		RemoteConnectionClose,
		DisconnectPeerCalled,
		ConnectionRejected,
		InvalidProtocol,
		UnknownHost,
		Reconnect,
		PeerToPeerConnection,
		PeerNotFound
	}
	public struct DisconnectInfo
	{
		public DisconnectReason Reason;

		public SocketError SocketErrorCode;

		public NetPacketReader AdditionalData;
	}
	public interface INetEventListener
	{
		void OnPeerConnected(NetPeer peer);

		void OnPeerDisconnected(NetPeer peer, DisconnectInfo disconnectInfo);

		void OnNetworkError(IPEndPoint endPoint, SocketError socketError);

		void OnNetworkReceive(NetPeer peer, NetPacketReader reader, byte channelNumber, DeliveryMethod deliveryMethod);

		void OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType);

		void OnNetworkLatencyUpdate(NetPeer peer, int latency);

		void OnConnectionRequest(ConnectionRequest request);
	}
	public interface IDeliveryEventListener
	{
		void OnMessageDelivered(NetPeer peer, object userData);
	}
	public interface INtpEventListener
	{
		void OnNtpResponse(NtpPacket packet);
	}
	public interface IPeerAddressChangedListener
	{
		void OnPeerAddressChanged(NetPeer peer, IPEndPoint previousAddress);
	}
	public class EventBasedNetListener : INetEventListener, IDeliveryEventListener, INtpEventListener, IPeerAddressChangedListener
	{
		public delegate void OnPeerConnected(NetPeer peer);

		public delegate void OnPeerDisconnected(NetPeer peer, DisconnectInfo disconnectInfo);

		public delegate void OnNetworkError(IPEndPoint endPoint, SocketError socketError);

		public delegate void OnNetworkReceive(NetPeer peer, NetPacketReader reader, byte channel, DeliveryMethod deliveryMethod);

		public delegate void OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType);

		public delegate void OnNetworkLatencyUpdate(NetPeer peer, int latency);

		public delegate void OnConnectionRequest(ConnectionRequest request);

		public delegate void OnDeliveryEvent(NetPeer peer, object userData);

		public delegate void OnNtpResponseEvent(NtpPacket packet);

		public delegate void OnPeerAddressChangedEvent(NetPeer peer, IPEndPoint previousAddress);

		public event OnPeerConnected PeerConnectedEvent;

		public event OnPeerDisconnected PeerDisconnectedEvent;

		public event OnNetworkError NetworkErrorEvent;

		public event OnNetworkReceive NetworkReceiveEvent;

		public event OnNetworkReceiveUnconnected NetworkReceiveUnconnectedEvent;

		public event OnNetworkLatencyUpdate NetworkLatencyUpdateEvent;

		public event OnConnectionRequest ConnectionRequestEvent;

		public event OnDeliveryEvent DeliveryEvent;

		public event OnNtpResponseEvent NtpResponseEvent;

		public event OnPeerAddressChangedEvent PeerAddressChangedEvent;

		public void ClearPeerConnectedEvent()
		{
			this.PeerConnectedEvent = null;
		}

		public void ClearPeerDisconnectedEvent()
		{
			this.PeerDisconnectedEvent = null;
		}

		public void ClearNetworkErrorEvent()
		{
			this.NetworkErrorEvent = null;
		}

		public void ClearNetworkReceiveEvent()
		{
			this.NetworkReceiveEvent = null;
		}

		public void ClearNetworkReceiveUnconnectedEvent()
		{
			this.NetworkReceiveUnconnectedEvent = null;
		}

		public void ClearNetworkLatencyUpdateEvent()
		{
			this.NetworkLatencyUpdateEvent = null;
		}

		public void ClearConnectionRequestEvent()
		{
			this.ConnectionRequestEvent = null;
		}

		public void ClearDeliveryEvent()
		{
			this.DeliveryEvent = null;
		}

		public void ClearNtpResponseEvent()
		{
			this.NtpResponseEvent = null;
		}

		public void ClearPeerAddressChangedEvent()
		{
			this.PeerAddressChangedEvent = null;
		}

		void INetEventListener.OnPeerConnected(NetPeer peer)
		{
			if (this.PeerConnectedEvent != null)
			{
				this.PeerConnectedEvent(peer);
			}
		}

		void INetEventListener.OnPeerDisconnected(NetPeer peer, DisconnectInfo disconnectInfo)
		{
			if (this.PeerDisconnectedEvent != null)
			{
				this.PeerDisconnectedEvent(peer, disconnectInfo);
			}
		}

		void INetEventListener.OnNetworkError(IPEndPoint endPoint, SocketError socketErrorCode)
		{
			if (this.NetworkErrorEvent != null)
			{
				this.NetworkErrorEvent(endPoint, socketErrorCode);
			}
		}

		void INetEventListener.OnNetworkReceive(NetPeer peer, NetPacketReader reader, byte channelNumber, DeliveryMethod deliveryMethod)
		{
			if (this.NetworkReceiveEvent != null)
			{
				this.NetworkReceiveEvent(peer, reader, channelNumber, deliveryMethod);
			}
		}

		void INetEventListener.OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType)
		{
			if (this.NetworkReceiveUnconnectedEvent != null)
			{
				this.NetworkReceiveUnconnectedEvent(remoteEndPoint, reader, messageType);
			}
		}

		void INetEventListener.OnNetworkLatencyUpdate(NetPeer peer, int latency)
		{
			if (this.NetworkLatencyUpdateEvent != null)
			{
				this.NetworkLatencyUpdateEvent(peer, latency);
			}
		}

		void INetEventListener.OnConnectionRequest(ConnectionRequest request)
		{
			if (this.ConnectionRequestEvent != null)
			{
				this.ConnectionRequestEvent(request);
			}
		}

		void IDeliveryEventListener.OnMessageDelivered(NetPeer peer, object userData)
		{
			if (this.DeliveryEvent != null)
			{
				this.DeliveryEvent(peer, userData);
			}
		}

		void INtpEventListener.OnNtpResponse(NtpPacket packet)
		{
			if (this.NtpResponseEvent != null)
			{
				this.NtpResponseEvent(packet);
			}
		}

		void IPeerAddressChangedListener.OnPeerAddressChanged(NetPeer peer, IPEndPoint previousAddress)
		{
			if (this.PeerAddressChangedEvent != null)
			{
				this.PeerAddressChangedEvent(peer, previousAddress);
			}
		}
	}
	internal sealed class NetConnectRequestPacket
	{
		public const int HeaderSize = 18;

		public readonly long ConnectionTime;

		public byte ConnectionNumber;

		public readonly byte[] TargetAddress;

		public readonly NetDataReader Data;

		public readonly int PeerId;

		private NetConnectRequestPacket(long connectionTime, byte connectionNumber, int localId, byte[] targetAddress, NetDataReader data)
		{
			ConnectionTime = connectionTime;
			ConnectionNumber = connectionNumber;
			TargetAddress = targetAddress;
			Data = data;
			PeerId = localId;
		}

		public static int GetProtocolId(NetPacket packet)
		{
			return BitConverter.ToInt32(packet.RawData, 1);
		}

		public static NetConnectRequestPacket FromData(NetPacket packet)
		{
			if (packet.ConnectionNumber >= 4)
			{
				return null;
			}
			long connectionTime = BitConverter.ToInt64(packet.RawData, 5);
			int localId = BitConverter.ToInt32(packet.RawData, 13);
			int num = packet.RawData[17];
			if (num != 16 && num != 28)
			{
				return null;
			}
			byte[] array = new byte[num];
			Buffer.BlockCopy(packet.RawData, 18, array, 0, num);
			NetDataReader netDataReader = new NetDataReader(null, 0, 0);
			if (packet.Size > 18 + num)
			{
				netDataReader.SetSource(packet.RawData, 18 + num, packet.Size);
			}
			return new NetConnectRequestPacket(connectionTime, packet.ConnectionNumber, localId, array, netDataReader);
		}

		public static NetPacket Make(NetDataWriter connectData, SocketAddress addressBytes, long connectTime, int localId)
		{
			NetPacket netPacket = new NetPacket(PacketProperty.ConnectRequest, connectData.Length + addressBytes.Size);
			FastBitConverter.GetBytes(netPacket.RawData, 1, 13);
			FastBitConverter.GetBytes(netPacket.RawData, 5, connectTime);
			FastBitConverter.GetBytes(netPacket.RawData, 13, localId);
			netPacket.RawData[17] = (byte)addressBytes.Size;
			for (int i = 0; i < addressBytes.Size; i++)
			{
				netPacket.RawData[18 + i] = addressBytes[i];
			}
			Buffer.BlockCopy(connectData.Data, 0, netPacket.RawData, 18 + addressBytes.Size, connectData.Length);
			return netPacket;
		}
	}
	internal sealed class NetConnectAcceptPacket
	{
		public const int Size = 15;

		public readonly long ConnectionTime;

		public readonly byte ConnectionNumber;

		public readonly int PeerId;

		public readonly bool PeerNetworkChanged;

		private NetConnectAcceptPacket(long connectionTime, byte connectionNumber, int peerId, bool peerNetworkChanged)
		{
			ConnectionTime = connectionTime;
			ConnectionNumber = connectionNumber;
			PeerId = peerId;
			PeerNetworkChanged = peerNetworkChanged;
		}

		public static NetConnectAcceptPacket FromData(NetPacket packet)
		{
			if (packet.Size != 15)
			{
				return null;
			}
			long connectionTime = BitConverter.ToInt64(packet.RawData, 1);
			byte b = packet.RawData[9];
			if (b >= 4)
			{
				return null;
			}
			byte b2 = packet.RawData[10];
			if (b2 > 1)
			{
				return null;
			}
			int num = BitConverter.ToInt32(packet.RawData, 11);
			if (num < 0)
			{
				return null;
			}
			return new NetConnectAcceptPacket(connectionTime, b, num, b2 == 1);
		}

		public static NetPacket Make(long connectTime, byte connectNum, int localPeerId)
		{
			NetPacket netPacket = new NetPacket(PacketProperty.ConnectAccept, 0);
			FastBitConverter.GetBytes(netPacket.RawData, 1, connectTime);
			netPacket.RawData[9] = connectNum;
			FastBitConverter.GetBytes(netPacket.RawData, 11, localPeerId);
			return netPacket;
		}

		public static NetPacket MakeNetworkChanged(NetPeer peer)
		{
			NetPacket netPacket = new NetPacket(PacketProperty.PeerNotFound, 14);
			FastBitConverter.GetBytes(netPacket.RawData, 1, peer.ConnectTime);
			netPacket.RawData[9] = peer.ConnectionNum;
			netPacket.RawData[10] = 1;
			FastBitConverter.GetBytes(netPacket.RawData, 11, peer.RemoteId);
			return netPacket;
		}
	}
	internal static class NativeSocket
	{
		private static class WinSock
		{
			private const string LibName = "ws2_32.dll";

			[DllImport("ws2_32.dll", SetLastError = true)]
			public static extern int recvfrom(IntPtr socketHandle, [In][Out] byte[] pinnedBuffer, [In] int len, [In] SocketFlags socketFlags, [Out] byte[] socketAddress, [In][Out] ref int socketAddressSize);

			[DllImport("ws2_32.dll", SetLastError = true)]
			internal unsafe static extern int sendto(IntPtr socketHandle, byte* pinnedBuffer, [In] int len, [In] SocketFlags socketFlags, [In] byte[] socketAddress, [In] int socketAddressSize);
		}

		private static class UnixSock
		{
			private const string LibName = "libc";

			[DllImport("libc", SetLastError = true)]
			public static extern int recvfrom(IntPtr socketHandle, [In][Out] byte[] pinnedBuffer, [In] int len, [In] SocketFlags socketFlags, [Out] byte[] socketAddress, [In][Out] ref int socketAddressSize);

			[DllImport("libc", SetLastError = true)]
			internal unsafe static extern int sendto(IntPtr socketHandle, byte* pinnedBuffer, [In] int len, [In] SocketFlags socketFlags, [In] byte[] socketAddress, [In] int socketAddressSize);
		}

		public static readonly bool IsSupported;

		public static readonly bool UnixMode;

		public const int IPv4AddrSize = 16;

		public const int IPv6AddrSize = 28;

		public const int AF_INET = 2;

		public const int AF_INET6 = 10;

		private static readonly Dictionary<int, SocketError> NativeErrorToSocketError;

		static NativeSocket()
		{
			IsSupported = false;
			UnixMode = false;
			NativeErrorToSocketError = new Dictionary<int, SocketError>
			{
				{
					13,
					SocketError.AccessDenied
				},
				{
					98,
					SocketError.AddressAlreadyInUse
				},
				{
					99,
					SocketError.AddressNotAvailable
				},
				{
					97,
					SocketError.AddressFamilyNotSupported
				},
				{
					11,
					SocketError.WouldBlock
				},
				{
					114,
					SocketError.AlreadyInProgress
				},
				{
					9,
					SocketError.OperationAborted
				},
				{
					125,
					SocketError.OperationAborted
				},
				{
					103,
					SocketError.ConnectionAborted
				},
				{
					111,
					SocketError.ConnectionRefused
				},
				{
					104,
					SocketError.ConnectionReset
				},
				{
					89,
					SocketError.DestinationAddressRequired
				},
				{
					14,
					SocketError.Fault
				},
				{
					112,
					SocketError.HostDown
				},
				{
					6,
					SocketError.HostNotFound
				},
				{
					113,
					SocketError.HostUnreachable
				},
				{
					115,
					SocketError.InProgress
				},
				{
					4,
					SocketError.Interrupted
				},
				{
					22,
					SocketError.InvalidArgument
				},
				{
					106,
					SocketError.IsConnected
				},
				{
					24,
					SocketError.TooManyOpenSockets
				},
				{
					90,
					SocketError.MessageSize
				},
				{
					100,
					SocketError.NetworkDown
				},
				{
					102,
					SocketError.NetworkReset
				},
				{
					101,
					SocketError.NetworkUnreachable
				},
				{
					23,
					SocketError.TooManyOpenSockets
				},
				{
					105,
					SocketError.NoBufferSpaceAvailable
				},
				{
					61,
					SocketError.NoData
				},
				{
					2,
					SocketError.AddressNotAvailable
				},
				{
					92,
					SocketError.ProtocolOption
				},
				{
					107,
					SocketError.NotConnected
				},
				{
					88,
					SocketError.NotSocket
				},
				{
					3440,
					SocketError.OperationNotSupported
				},
				{
					1,
					SocketError.AccessDenied
				},
				{
					32,
					SocketError.Shutdown
				},
				{
					96,
					SocketError.ProtocolFamilyNotSupported
				},
				{
					93,
					SocketError.ProtocolNotSupported
				},
				{
					91,
					SocketError.ProtocolType
				},
				{
					94,
					SocketError.SocketNotSupported
				},
				{
					108,
					SocketError.Disconnecting
				},
				{
					110,
					SocketError.TimedOut
				},
				{
					0,
					SocketError.Success
				}
			};
			if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
			{
				IsSupported = true;
				UnixMode = true;
			}
			else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
			{
				IsSupported = true;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int RecvFrom(IntPtr socketHandle, byte[] pinnedBuffer, int len, byte[] socketAddress, ref int socketAddressSize)
		{
			if (!UnixMode)
			{
				return WinSock.recvfrom(socketHandle, pinnedBuffer, len, SocketFlags.None, socketAddress, ref socketAddressSize);
			}
			return UnixSock.recvfrom(socketHandle, pinnedBuffer, len, SocketFlags.None, socketAddress, ref socketAddressSize);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static int SendTo(IntPtr socketHandle, byte* pinnedBuffer, int len, byte[] socketAddress, int socketAddressSize)
		{
			if (!UnixMode)
			{
				return WinSock.sendto(socketHandle, pinnedBuffer, len, SocketFlags.None, socketAddress, socketAddressSize);
			}
			return UnixSock.sendto(socketHandle, pinnedBuffer, len, SocketFlags.None, socketAddress, socketAddressSize);
		}

		public static SocketError GetSocketError()
		{
			int lastWin32Error = Marshal.GetLastWin32Error();
			if (UnixMode)
			{
				if (!NativeErrorToSocketError.TryGetValue(lastWin32Error, out var value))
				{
					return SocketError.SocketError;
				}
				return value;
			}
			return (SocketError)lastWin32Error;
		}

		public static SocketException GetSocketException()
		{
			int lastWin32Error = Marshal.GetLastWin32Error();
			if (UnixMode)
			{
				if (!NativeErrorToSocketError.TryGetValue(lastWin32Error, out var value))
				{
					return new SocketException(-1);
				}
				return new SocketException((int)value);
			}
			return new SocketException(lastWin32Error);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short GetNativeAddressFamily(IPEndPoint remoteEndPoint)
		{
			if (!UnixMode)
			{
				return (short)remoteEndPoint.AddressFamily;
			}
			return (short)((remoteEndPoint.AddressFamily == AddressFamily.InterNetwork) ? 2 : 10);
		}
	}
	public enum NatAddressType
	{
		Internal,
		External
	}
	public interface INatPunchListener
	{
		void OnNatIntroductionRequest(IPEndPoint localEndPoint, IPEndPoint remoteEndPoint, string token);

		void OnNatIntroductionSuccess(IPEndPoint targetEndPoint, NatAddressType type, string token);
	}
	public class EventBasedNatPunchListener : INatPunchListener
	{
		public delegate void OnNatIntroductionRequest(IPEndPoint localEndPoint, IPEndPoint remoteEndPoint, string token);

		public delegate void OnNatIntroductionSuccess(IPEndPoint targetEndPoint, NatAddressType type, string token);

		public event OnNatIntroductionRequest NatIntroductionRequest;

		public event OnNatIntroductionSuccess NatIntroductionSuccess;

		void INatPunchListener.OnNatIntroductionRequest(IPEndPoint localEndPoint, IPEndPoint remoteEndPoint, string token)
		{
			if (this.NatIntroductionRequest != null)
			{
				this.NatIntroductionRequest(localEndPoint, remoteEndPoint, token);
			}
		}

		void INatPunchListener.OnNatIntroductionSuccess(IPEndPoint targetEndPoint, NatAddressType type, string token)
		{
			if (this.NatIntroductionSuccess != null)
			{
				this.NatIntroductionSuccess(targetEndPoint, type, token);
			}
		}
	}
	public sealed class NatPunchModule
	{
		private struct RequestEventData
		{
			public IPEndPoint LocalEndPoint;

			public IPEndPoint RemoteEndPoint;

			public string Token;
		}

		private struct SuccessEventData
		{
			public IPEndPoint TargetEndPoint;

			public NatAddressType Type;

			public string Token;
		}

		private class NatIntroduceRequestPacket
		{
			public IPEndPoint Internal
			{
				[LiteNetLib.Utils.Preserve]
				get;
				[LiteNetLib.Utils.Preserve]
				set;
			}

			public string Token
			{
				[LiteNetLib.Utils.Preserve]
				get;
				[LiteNetLib.Utils.Preserve]
				set;
			}
		}

		private class NatIntroduceResponsePacket
		{
			public IPEndPoint Internal
			{
				[LiteNetLib.Utils.Preserve]
				get;
				[LiteNetLib.Utils.Preserve]
				set;
			}

			public IPEndPoint External
			{
				[LiteNetLib.Utils.Preserve]
				get;
				[LiteNetLib.Utils.Preserve]
				set;
			}

			public string Token
			{
				[LiteNetLib.Utils.Preserve]
				get;
				[LiteNetLib.Utils.Preserve]
				set;
			}
		}

		private class NatPunchPacket
		{
			public string Token
			{
				[LiteNetLib.Utils.Preserve]
				get;
				[LiteNetLib.Utils.Preserve]
				set;
			}

			public bool IsExternal
			{
				[LiteNetLib.Utils.Preserve]
				get;
				[LiteNetLib.Utils.Preserve]
				set;
			}
		}

		private readonly NetManager _socket;

		private readonly ConcurrentQueue<RequestEventData> _requestEvents = new ConcurrentQueue<RequestEventData>();

		private readonly ConcurrentQueue<SuccessEventData> _successEvents = new ConcurrentQueue<SuccessEventData>();

		private readonly NetDataReader _cacheReader = new NetDataReader();

		private readonly NetDataWriter _cacheWriter = new NetDataWriter();

		private readonly NetPacketProcessor _netPacketProcessor = new NetPacketProcessor(256);

		private INatPunchListener _natPunchListener;

		public const int MaxTokenLength = 256;

		public bool UnsyncedEvents;

		internal NatPunchModule(NetManager socket)
		{
			_socket = socket;
			_netPacketProcessor.SubscribeReusable<NatIntroduceResponsePacket>(OnNatIntroductionResponse);
			_netPacketProcessor.SubscribeReusable<NatIntroduceRequestPacket, IPEndPoint>(OnNatIntroductionRequest);
			_netPacketProcessor.SubscribeReusable<NatPunchPacket, IPEndPoint>(OnNatPunch);
		}

		internal void ProcessMessage(IPEndPoint senderEndPoint, NetPacket packet)
		{
			lock (_cacheReader)
			{
				_cacheReader.SetSource(packet.RawData, 1, packet.Size);
				_netPacketProcessor.ReadAllPackets(_cacheReader, senderEndPoint);
			}
		}

		public void Init(INatPunchListener listener)
		{
			_natPunchListener = listener;
		}

		private void Send<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T packet, IPEndPoint target) where T : class, new()
		{
			_cacheWriter.Reset();
			_cacheWriter.Put((byte)16);
			_netPacketProcessor.Write(_cacheWriter, packet);
			_socket.SendRaw(_cacheWriter.Data, 0, _cacheWriter.Length, target);
		}

		public void NatIntroduce(IPEndPoint hostInternal, IPEndPoint hostExternal, IPEndPoint clientInternal, IPEndPoint clientExternal, string additionalInfo)
		{
			NatIntroduceResponsePacket natIntroduceResponsePacket = new NatIntroduceResponsePacket
			{
				Token = additionalInfo
			};
			natIntroduceResponsePacket.Internal = hostInternal;
			natIntroduceResponsePacket.External = hostExternal;
			Send(natIntroduceResponsePacket, clientExternal);
			natIntroduceResponsePacket.Internal = clientInternal;
			natIntroduceResponsePacket.External = clientExternal;
			Send(natIntroduceResponsePacket, hostExternal);
		}

		public void PollEvents()
		{
			if (!UnsyncedEvents && _natPunchListener != null && (!_successEvents.IsEmpty || !_requestEvents.IsEmpty))
			{
				SuccessEventData result;
				while (_successEvents.TryDequeue(out result))
				{
					_natPunchListener.OnNatIntroductionSuccess(result.TargetEndPoint, result.Type, result.Token);
				}
				RequestEventData result2;
				while (_requestEvents.TryDequeue(out result2))
				{
					_natPunchListener.OnNatIntroductionRequest(result2.LocalEndPoint, result2.RemoteEndPoint, result2.Token);
				}
			}
		}

		public void SendNatIntroduceRequest(string host, int port, string additionalInfo)
		{
			SendNatIntroduceRequest(NetUtils.MakeEndPoint(host, port), additionalInfo);
		}

		public void SendNatIntroduceRequest(IPEndPoint masterServerEndPoint, string additionalInfo)
		{
			string localIp = NetUtils.GetLocalIp(LocalAddrType.IPv4);
			if (string.IsNullOrEmpty(localIp) || masterServerEndPoint.AddressFamily == AddressFamily.InterNetworkV6)
			{
				localIp = NetUtils.GetLocalIp(LocalAddrType.IPv6);
			}
			Send(new NatIntroduceRequestPacket
			{
				Internal = NetUtils.MakeEndPoint(localIp, _socket.LocalPort),
				Token = additionalInfo
			}, masterServerEndPoint);
		}

		private void OnNatIntroductionRequest(NatIntroduceRequestPacket req, IPEndPoint senderEndPoint)
		{
			if (UnsyncedEvents)
			{
				_natPunchListener.OnNatIntroductionRequest(req.Internal, senderEndPoint, req.Token);
				return;
			}
			_requestEvents.Enqueue(new RequestEventData
			{
				LocalEndPoint = req.Internal,
				RemoteEndPoint = senderEndPoint,
				Token = req.Token
			});
		}

		private void OnNatIntroductionResponse(NatIntroduceResponsePacket req)
		{
			NatPunchPacket natPunchPacket = new NatPunchPacket
			{
				Token = req.Token
			};
			Send(natPunchPacket, req.Internal);
			_socket.Ttl = 2;
			_socket.SendRaw(new byte[1] { 17 }, 0, 1, req.External);
			_socket.Ttl = 255;
			natPunchPacket.IsExternal = true;
			Send(natPunchPacket, req.External);
		}

		private void OnNatPunch(NatPunchPacket req, IPEndPoint senderEndPoint)
		{
			if (UnsyncedEvents)
			{
				_natPunchListener.OnNatIntroductionSuccess(senderEndPoint, req.IsExternal ? NatAddressType.External : NatAddressType.Internal, req.Token);
				return;
			}
			_successEvents.Enqueue(new SuccessEventData
			{
				TargetEndPoint = senderEndPoint,
				Type = (req.IsExternal ? NatAddressType.External : NatAddressType.Internal),
				Token = req.Token
			});
		}
	}
	public enum DeliveryMethod : byte
	{
		Unreliable = 4,
		ReliableUnordered = 0,
		Sequenced = 1,
		ReliableOrdered = 2,
		ReliableSequenced = 3
	}
	public static class NetConstants
	{
		public const int DefaultWindowSize = 64;

		public const int SocketBufferSize = 1048576;

		public const int SocketTTL = 255;

		public const int HeaderSize = 1;

		public const int ChanneledHeaderSize = 4;

		public const int FragmentHeaderSize = 6;

		public const int FragmentedHeaderTotalSize = 10;

		public const ushort MaxSequence = 32768;

		public const ushort HalfMaxSequence = 16384;

		internal const int ProtocolId = 13;

		internal const int MaxUdpHeaderSize = 68;

		internal const int ChannelTypeCount = 4;

		internal static readonly int[] PossibleMtu = new int[6] { 1024, 1164, 1392, 1404, 1424, 1432 };

		public static readonly int InitialMtu = PossibleMtu[0];

		public static readonly int MaxPacketSize = PossibleMtu[PossibleMtu.Length - 1];

		public static readonly int MaxUnreliableDataSize = MaxPacketSize - 1;

		public const byte MaxConnectionNumber = 4;
	}
	public class InvalidPacketException : ArgumentException
	{
		public InvalidPacketException(string message)
			: base(message)
		{
		}
	}
	public class TooBigPacketException : InvalidPacketException
	{
		public TooBigPacketException(string message)
			: base(message)
		{
		}
	}
	public enum NetLogLevel
	{
		Warning,
		Error,
		Trace,
		Info
	}
	public interface INetLogger
	{
		void WriteNet(NetLogLevel level, string str, params object[] args);
	}
	public static class NetDebug
	{
		public static INetLogger Logger = null;

		private static readonly object DebugLogLock = new object();

		private static void WriteLogic(NetLogLevel logLevel, string str, params object[] args)
		{
			lock (DebugLogLock)
			{
				if (Logger == null)
				{
					Console.WriteLine(str, args);
				}
				else
				{
					Logger.WriteNet(logLevel, str, args);
				}
			}
		}

		[Conditional("DEBUG_MESSAGES")]
		internal static void Write(string str)
		{
			WriteLogic(NetLogLevel.Trace, str);
		}

		[Conditional("DEBUG_MESSAGES")]
		internal static void Write(NetLogLevel level, string str)
		{
			WriteLogic(level, str);
		}

		[Conditional("DEBUG_MESSAGES")]
		[Conditional("DEBUG")]
		internal static void WriteForce(string str)
		{
			WriteLogic(NetLogLevel.Trace, str);
		}

		[Conditional("DEBUG_MESSAGES")]
		[Conditional("DEBUG")]
		internal static void WriteForce(NetLogLevel level, string str)
		{
			WriteLogic(level, str);
		}

		internal static void WriteError(string str)
		{
			WriteLogic(NetLogLevel.Error, str);
		}
	}
	public sealed class NetPacketReader : NetDataReader
	{
		private NetPacket _packet;

		private readonly NetManager _manager;

		private readonly NetEvent _evt;

		internal NetPacketReader(NetManager manager, NetEvent evt)
		{
			_manager = manager;
			_evt = evt;
		}

		internal void SetSource(NetPacket packet, int headerSize)
		{
			if (packet != null)
			{
				_packet = packet;
				SetSource(packet.RawData, headerSize, packet.Size);
			}
		}

		internal void RecycleInternal()
		{
			Clear();
			if (_packet != null)
			{
				_manager.PoolRecycle(_packet);
			}
			_packet = null;
			_manager.RecycleEvent(_evt);
		}

		public void Recycle()
		{
			if (!_manager.AutoRecycle)
			{
				RecycleInternal();
			}
		}
	}
	internal sealed class NetEvent
	{
		public enum EType
		{
			Connect,
			Disconnect,
			Receive,
			ReceiveUnconnected,
			Error,
			ConnectionLatencyUpdated,
			Broadcast,
			ConnectionRequest,
			MessageDelivered,
			PeerAddressChanged
		}

		public NetEvent Next;

		public EType Type;

		public NetPeer Peer;

		public IPEndPoint RemoteEndPoint;

		public object UserData;

		public int Latency;

		public SocketError ErrorCode;

		public DisconnectReason DisconnectReason;

		public ConnectionRequest ConnectionRequest;

		public DeliveryMethod DeliveryMethod;

		public byte ChannelNumber;

		public readonly NetPacketReader DataReader;

		public NetEvent(NetManager manager)
		{
			DataReader = new NetPacketReader(manager, this);
		}
	}
	public class NetManager : IEnumerable<NetPeer>, IEnumerable
	{
		public struct NetPeerEnumerator : IEnumerator<NetPeer>, IEnumerator, IDisposable
		{
			private readonly NetPeer _initialPeer;

			private NetPeer _p;

			public NetPeer Current => _p;

			object IEnumerator.Current => _p;

			public NetPeerEnumerator(NetPeer p)
			{
				_initialPeer = p;
				_p = null;
			}

			public void Dispose()
			{
			}

			public bool MoveNext()
			{
				_p = ((_p == null) ? _initialPeer : _p.NextPeer);
				return _p != null;
			}

			public void Reset()
			{
				throw new NotSupportedException();
			}
		}

		private struct IncomingData
		{
			public NetPacket Data;

			public IPEndPoint EndPoint;

			public DateTime TimeWhenGet;
		}

		private struct Slot
		{
			internal int HashCode;

			internal int Next;

			internal NetPeer Value;
		}

		private readonly List<IncomingData> _pingSimulationList = new List<IncomingData>();

		private readonly Random _randomGenerator = new Random();

		private const int MinLatencyThreshold = 5;

		private Thread _logicThread;

		private bool _manualMode;

		private readonly AutoResetEvent _updateTriggerEvent = new AutoResetEvent(initialState: true);

		private NetEvent _pendingEventHead;

		private NetEvent _pendingEventTail;

		private NetEvent _netEventPoolHead;

		private readonly INetEventListener _netEventListener;

		private readonly IDeliveryEventListener _deliveryEventListener;

		private readonly INtpEventListener _ntpEventListener;

		private readonly IPeerAddressChangedListener _peerAddressChangedListener;

		private readonly Dictionary<IPEndPoint, ConnectionRequest> _requestsDict = new Dictionary<IPEndPoint, ConnectionRequest>();

		private readonly ConcurrentDictionary<IPEndPoint, NtpRequest> _ntpRequests = new ConcurrentDictionary<IPEndPoint, NtpRequest>();

		private long _connectedPeersCount;

		private readonly List<NetPeer> _connectedPeerListCache = new List<NetPeer>();

		private readonly PacketLayerBase _extraPacketLayer;

		private int _lastPeerId;

		private ConcurrentQueue<int> _peerIds = new ConcurrentQueue<int>();

		private byte _channelsCount = 1;

		private readonly object _eventLock = new object();

		private bool _dropPacket;

		public bool UnconnectedMessagesEnabled;

		public bool NatPunchEnabled;

		public int UpdateTime = 15;

		public int PingInterval = 1000;

		public int DisconnectTimeout = 5000;

		public bool SimulatePacketLoss;

		public bool SimulateLatency;

		public int SimulationPacketLossChance = 10;

		public int SimulationMinLatency = 30;

		public int SimulationMaxLatency = 100;

		public bool UnsyncedEvents;

		public bool UnsyncedReceiveEvent;

		public bool UnsyncedDeliveryEvent;

		public bool BroadcastReceiveEnabled;

		public int ReconnectDelay = 500;

		public int MaxConnectAttempts = 10;

		public bool ReuseAddress;

		public bool DontRoute;

		public readonly NetStatistics Statistics = new NetStatistics();

		public bool EnableStatistics;

		public readonly NatPunchModule NatPunchModule;

		public bool AutoRecycle;

		public bool IPv6Enabled = true;

		public int MtuOverride;

		public bool MtuDiscovery;

		public bool UseNativeSockets;

		public bool DisconnectOnUnreachable;

		public bool AllowPeerAddressChange;

		private const int MaxPrimeArrayLength = 2147483587;

		private const int HashPrime = 101;

		private const int Lower31BitMask = int.MaxValue;

		private static readonly int[] Primes;

		private int[] _buckets;

		private Slot[] _slots;

		private int _count;

		private int _lastIndex;

		private int _freeList = -1;

		private NetPeer[] _peersArray = new NetPeer[32];

		private readonly ReaderWriterLockSlim _peersLock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);

		private volatile NetPeer _headPeer;

		private NetPacket _poolHead;

		private int _poolCount;

		private readonly object _poolLock = new object();

		public int PacketPoolSize = 1000;

		private const int ReceivePollingTime = 500000;

		private System.Net.Sockets.Socket _udpSocketv4;

		private System.Net.Sockets.Socket _udpSocketv6;

		private Thread _receiveThread;

		private IPEndPoint _bufferEndPointv4;

		private IPEndPoint _bufferEndPointv6;

		private const int SioUdpConnreset = -1744830452;

		private static readonly IPAddress MulticastAddressV6;

		public static readonly bool IPv6Support;

		internal bool NotConnected;

		public bool IsRunning { get; private set; }

		public int LocalPort { get; private set; }

		public NetPeer FirstPeer => _headPeer;

		public byte ChannelsCount
		{
			get
			{
				return _channelsCount;
			}
			set
			{
				if (value < 1 || value > 64)
				{
					throw new ArgumentException("Channels count must be between 1 and 64");
				}
				_channelsCount = value;
			}
		}

		public List<NetPeer> ConnectedPeerList
		{
			get
			{
				GetPeersNonAlloc(_connectedPeerListCache, ConnectionState.Connected);
				return _connectedPeerListCache;
			}
		}

		public int ConnectedPeersCount => (int)Interlocked.Read(ref _connectedPeersCount);

		public int ExtraPacketSizeForLayer => _extraPacketLayer?.ExtraPacketSizeForLayer ?? 0;

		public int PoolCount => _poolCount;

		public short Ttl
		{
			get
			{
				return _udpSocketv4.Ttl;
			}
			internal set
			{
				_udpSocketv4.Ttl = value;
			}
		}

		public NetManager(INetEventListener listener, PacketLayerBase extraPacketLayer = null)
		{
			_netEventListener = listener;
			_deliveryEventListener = listener as IDeliveryEventListener;
			_ntpEventListener = listener as INtpEventListener;
			_peerAddressChangedListener = listener as IPeerAddressChangedListener;
			NatPunchModule = new NatPunchModule(this);
			_extraPacketLayer = extraPacketLayer;
		}

		internal void ConnectionLatencyUpdated(NetPeer fromPeer, int latency)
		{
			CreateEvent(NetEvent.EType.ConnectionLatencyUpdated, fromPeer, null, SocketError.Success, latency, DisconnectReason.ConnectionFailed, null, DeliveryMethod.Unreliable, 0);
		}

		internal void MessageDelivered(NetPeer fromPeer, object userData)
		{
			if (_deliveryEventListener != null)
			{
				CreateEvent(NetEvent.EType.MessageDelivered, fromPeer, null, SocketError.Success, 0, DisconnectReason.ConnectionFailed, null, DeliveryMethod.Unreliable, 0, null, userData);
			}
		}

		internal void DisconnectPeerForce(NetPeer peer, DisconnectReason reason, SocketError socketErrorCode, NetPacket eventData)
		{
			DisconnectPeer(peer, reason, socketErrorCode, force: true, null, 0, 0, eventData);
		}

		private void DisconnectPeer(NetPeer peer, DisconnectReason reason, SocketError socketErrorCode, bool force, byte[] data, int start, int count, NetPacket eventData)
		{
			switch (peer.Shutdown(data, start, count, force))
			{
			case ShutdownResult.None:
				return;
			case ShutdownResult.WasConnected:
				Interlocked.Decrement(ref _connectedPeersCount);
				break;
			}
			CreateEvent(NetEvent.EType.Disconnect, peer, null, socketErrorCode, 0, reason, null, DeliveryMethod.Unreliable, 0, eventData);
		}

		private void CreateEvent(NetEvent.EType type, NetPeer peer = null, IPEndPoint remoteEndPoint = null, SocketError errorCode = SocketError.Success, int latency = 0, DisconnectReason disconnectReason = DisconnectReason.ConnectionFailed, ConnectionRequest connectionRequest = null, DeliveryMethod deliveryMethod = DeliveryMethod.Unreliable, byte channelNumber = 0, NetPacket readerSource = null, object userData = null)
		{
			bool flag = UnsyncedEvents;
			switch (type)
			{
			case NetEvent.EType.Connect:
				Interlocked.Increment(ref _connectedPeersCount);
				break;
			case NetEvent.EType.MessageDelivered:
				flag = UnsyncedDeliveryEvent;
				break;
			}
			NetEvent netEvent;
			lock (_eventLock)
			{
				netEvent = _netEventPoolHead;
				if (netEvent == null)
				{
					netEvent = new NetEvent(this);
				}
				else
				{
					_netEventPoolHead = netEvent.Next;
				}
			}
			netEvent.Next = null;
			netEvent.Type = type;
			netEvent.DataReader.SetSource(readerSource, readerSource?.GetHeaderSize() ?? 0);
			netEvent.Peer = peer;
			netEvent.RemoteEndPoint = remoteEndPoint;
			netEvent.Latency = latency;
			netEvent.ErrorCode = errorCode;
			netEvent.DisconnectReason = disconnectReason;
			netEvent.ConnectionRequest = connectionRequest;
			netEvent.DeliveryMethod = deliveryMethod;
			netEvent.ChannelNumber = channelNumber;
			netEvent.UserData = userData;
			if (flag || _manualMode)
			{
				ProcessEvent(netEvent);
				return;
			}
			lock (_eventLock)
			{
				if (_pendingEventTail == null)
				{
					_pendingEventHead = netEvent;
				}
				else
				{
					_pendingEventTail.Next = netEvent;
				}
				_pendingEventTail = netEvent;
			}
		}

		private void ProcessEvent(NetEvent evt)
		{
			bool isNull = evt.DataReader.IsNull;
			switch (evt.Type)
			{
			case NetEvent.EType.Connect:
				_netEventListener.OnPeerConnected(evt.Peer);
				break;
			case NetEvent.EType.Disconnect:
			{
				DisconnectInfo disconnectInfo = default(DisconnectInfo);
				disconnectInfo.Reason = evt.DisconnectReason;
				disconnectInfo.AdditionalData = evt.DataReader;
				disconnectInfo.SocketErrorCode = evt.ErrorCode;
				DisconnectInfo disconnectInfo2 = disconnectInfo;
				_netEventListener.OnPeerDisconnected(evt.Peer, disconnectInfo2);
				break;
			}
			case NetEvent.EType.Receive:
				_netEventListener.OnNetworkReceive(evt.Peer, evt.DataReader, evt.ChannelNumber, evt.DeliveryMethod);
				break;
			case NetEvent.EType.ReceiveUnconnected:
				_netEventListener.OnNetworkReceiveUnconnected(evt.RemoteEndPoint, evt.DataReader, UnconnectedMessageType.BasicMessage);
				break;
			case NetEvent.EType.Broadcast:
				_netEventListener.OnNetworkReceiveUnconnected(evt.RemoteEndPoint, evt.DataReader, UnconnectedMessageType.Broadcast);
				break;
			case NetEvent.EType.Error:
				_netEventListener.OnNetworkError(evt.RemoteEndPoint, evt.ErrorCode);
				break;
			case NetEvent.EType.ConnectionLatencyUpdated:
				_netEventListener.OnNetworkLatencyUpdate(evt.Peer, evt.Latency);
				break;
			case NetEvent.EType.ConnectionRequest:
				_netEventListener.OnConnectionRequest(evt.ConnectionRequest);
				break;
			case NetEvent.EType.MessageDelivered:
				_deliveryEventListener.OnMessageDelivered(evt.Peer, evt.UserData);
				break;
			case NetEvent.EType.PeerAddressChanged:
			{
				_peersLock.EnterUpgradeableReadLock();
				IPEndPoint iPEndPoint = null;
				if (ContainsPeer(evt.Peer))
				{
					_peersLock.EnterWriteLock();
					RemovePeerFromSet(evt.Peer);
					iPEndPoint = new IPEndPoint(evt.Peer.Address, evt.Peer.Port);
					evt.Peer.FinishEndPointChange(evt.RemoteEndPoint);
					AddPeerToSet(evt.Peer);
					_peersLock.ExitWriteLock();
				}
				_peersLock.ExitUpgradeableReadLock();
				if (iPEndPoint != null && _peerAddressChangedListener != null)
				{
					_peerAddressChangedListener.OnPeerAddressChanged(evt.Peer, iPEndPoint);
				}
				break;
			}
			}
			if (isNull)
			{
				RecycleEvent(evt);
			}
			else if (AutoRecycle)
			{
				evt.DataReader.RecycleInternal();
			}
		}

		internal void RecycleEvent(NetEvent evt)
		{
			evt.Peer = null;
			evt.ErrorCode = SocketError.Success;
			evt.RemoteEndPoint = null;
			evt.ConnectionRequest = null;
			lock (_eventLock)
			{
				evt.Next = _netEventPoolHead;
				_netEventPoolHead = evt;
			}
		}

		private void UpdateLogic()
		{
			List<NetPeer> list = new List<NetPeer>();
			Stopwatch stopwatch = new Stopwatch();
			stopwatch.Start();
			while (IsRunning)
			{
				try
				{
					float num = (float)((double)stopwatch.ElapsedTicks / (double)Stopwatch.Frequency * 1000.0);
					num = ((num <= 0f) ? 0.001f : num);
					stopwatch.Restart();
					for (NetPeer netPeer = _headPeer; netPeer != null; netPeer = netPeer.NextPeer)
					{
						if (netPeer.ConnectionState == ConnectionState.Disconnected && netPeer.TimeSinceLastPacket > (float)DisconnectTimeout)
						{
							list.Add(netPeer);
						}
						else
						{
							netPeer.Update(num);
						}
					}
					if (list.Count > 0)
					{
						_peersLock.EnterWriteLock();
						for (int i = 0; i < list.Count; i++)
						{
							RemovePeer(list[i], enableWriteLock: false);
						}
						_peersLock.ExitWriteLock();
						list.Clear();
					}
					ProcessNtpRequests(num);
					int num2 = UpdateTime - (int)stopwatch.ElapsedMilliseconds;
					if (num2 > 0)
					{
						_updateTriggerEvent.WaitOne(num2);
					}
				}
				catch (ThreadAbortException)
				{
					return;
				}
				catch (Exception ex2)
				{
					NetDebug.WriteError("[NM] LogicThread error: " + ex2);
				}
			}
			stopwatch.Stop();
		}

		[Conditional("DEBUG")]
		private void ProcessDelayedPackets()
		{
			if (!SimulateLatency)
			{
				return;
			}
			DateTime utcNow = DateTime.UtcNow;
			lock (_pingSimulationList)
			{
				for (int i = 0; i < _pingSimulationList.Count; i++)
				{
					IncomingData incomingData = _pingSimulationList[i];
					if (incomingData.TimeWhenGet <= utcNow)
					{
						HandleMessageReceived(incomingData.Data, incomingData.EndPoint);
						_pingSimulationList.RemoveAt(i);
						i--;
					}
				}
			}
		}

		private void ProcessNtpRequests(float elapsedMilliseconds)
		{
			List<IPEndPoint> list = null;
			foreach (KeyValuePair<IPEndPoint, NtpRequest> ntpRequest in _ntpRequests)
			{
				ntpRequest.Value.Send(_udpSocketv4, elapsedMilliseconds);
				if (ntpRequest.Value.NeedToKill)
				{
					if (list == null)
					{
						list = new List<IPEndPoint>();
					}
					list.Add(ntpRequest.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (IPEndPoint item in list)
			{
				_ntpRequests.TryRemove(item, out var _);
			}
		}

		public void ManualUpdate(float elapsedMilliseconds)
		{
			if (!_manualMode)
			{
				return;
			}
			for (NetPeer netPeer = _headPeer; netPeer != null; netPeer = netPeer.NextPeer)
			{
				if (netPeer.ConnectionState == ConnectionState.Disconnected && netPeer.TimeSinceLastPacket > (float)DisconnectTimeout)
				{
					RemovePeer(netPeer, enableWriteLock: false);
				}
				else
				{
					netPeer.Update(elapsedMilliseconds);
				}
			}
			ProcessNtpRequests(elapsedMilliseconds);
		}

		internal NetPeer OnConnectionSolved(ConnectionRequest request, byte[] rejectData, int start, int length)
		{
			NetPeer actualValue = null;
			if (request.Result == ConnectionRequestResult.RejectForce)
			{
				if (rejectData != null && length > 0)
				{
					NetPacket netPacket = PoolGetWithProperty(PacketProperty.Disconnect, length);
					netPacket.ConnectionNumber = request.InternalPacket.ConnectionNumber;
					FastBitConverter.GetBytes(netPacket.RawData, 1, request.InternalPacket.ConnectionTime);
					if (netPacket.Size >= NetConstants.PossibleMtu[0])
					{
						NetDebug.WriteError("[Peer] Disconnect additional data size more than MTU!");
					}
					else
					{
						Buffer.BlockCopy(rejectData, start, netPacket.RawData, 9, length);
					}
					SendRawAndRecycle(netPacket, request.RemoteEndPoint);
				}
				lock (_requestsDict)
				{
					_requestsDict.Remove(request.RemoteEndPoint);
				}
			}
			else
			{
				lock (_requestsDict)
				{
					if (!TryGetPeer(request.RemoteEndPoint, out actualValue))
					{
						if (request.Result == ConnectionRequestResult.Reject)
						{
							actualValue = new NetPeer(this, request.RemoteEndPoint, GetNextPeerId());
							actualValue.Reject(request.InternalPacket, rejectData, start, length);
							AddPeer(actualValue);
						}
						else
						{
							actualValue = new NetPeer(this, request, GetNextPeerId());
							AddPeer(actualValue);
							CreateEvent(NetEvent.EType.Connect, actualValue, null, SocketError.Success, 0, DisconnectReason.ConnectionFailed, null, DeliveryMethod.Unreliable, 0);
						}
					}
					_requestsDict.Remove(request.RemoteEndPoint);
				}
			}
			return actualValue;
		}

		private int GetNextPeerId()
		{
			if (!_peerIds.TryDequeue(out var result))
			{
				return _lastPeerId++;
			}
			return result;
		}

		private void ProcessConnectRequest(IPEndPoint remoteEndPoint, NetPeer netPeer, NetConnectRequestPacket connRequest)
		{
			if (netPeer != null)
			{
				ConnectRequestResult connectRequestResult = netPeer.ProcessConnectRequest(connRequest);
				switch (connectRequestResult)
				{
				default:
					return;
				case ConnectRequestResult.Reconnection:
					DisconnectPeerForce(netPeer, DisconnectReason.Reconnect, SocketError.Success, null);
					RemovePeer(netPeer, enableWriteLock: true);
					break;
				case ConnectRequestResult.NewConnection:
					RemovePeer(netPeer, enableWriteLock: true);
					break;
				case ConnectRequestResult.P2PLose:
					DisconnectPeerForce(netPeer, DisconnectReason.PeerToPeerConnection, SocketError.Success, null);
					RemovePeer(netPeer, enableWriteLock: true);
					break;
				}
				if (connectRequestResult != ConnectRequestResult.P2PLose)
				{
					connRequest.ConnectionNumber = (byte)((netPeer.ConnectionNum + 1) % 4);
				}
			}
			ConnectionRequest value;
			lock (_requestsDict)
			{
				if (_requestsDict.TryGetValue(remoteEndPoint, out value))
				{
					value.UpdateRequest(connRequest);
					return;
				}
				value = new ConnectionRequest(remoteEndPoint, connRequest, this);
				_requestsDict.Add(remoteEndPoint, value);
			}
			CreateEvent(NetEvent.EType.ConnectionRequest, null, null, SocketError.Success, 0, DisconnectReason.ConnectionFailed, value, DeliveryMethod.Unreliable, 0);
		}

		private void OnMessageReceived(NetPacket packet, IPEndPoint remoteEndPoint)
		{
			if (packet.Size == 0)
			{
				PoolRecycle(packet);
				return;
			}
			_dropPacket = false;
			if (!_dropPacket)
			{
				HandleMessageReceived(packet, remoteEndPoint);
			}
		}

		[Conditional("DEBUG")]
		private void HandleSimulateLatency(NetPacket packet, IPEndPoint remoteEndPoint)
		{
			if (!SimulateLatency)
			{
				return;
			}
			int num = _randomGenerator.Next(SimulationMinLatency, SimulationMaxLatency);
			if (num > 5)
			{
				lock (_pingSimulationList)
				{
					_pingSimulationList.Add(new IncomingData
					{
						Data = packet,
						EndPoint = remoteEndPoint,
						TimeWhenGet = DateTime.UtcNow.AddMilliseconds(num)
					});
				}
				_dropPacket = true;
			}
		}

		[Conditional("DEBUG")]
		private void HandleSimulatePacketLoss()
		{
			if (SimulatePacketLoss && _randomGenerator.NextDouble() * 100.0 < (double)SimulationPacketLossChance)
			{
				_dropPacket = true;
			}
		}

		private void HandleMessageReceived(NetPacket packet, IPEndPoint remoteEndPoint)
		{
			int size = packet.Size;
			if (EnableStatistics)
			{
				Statistics.IncrementPacketsReceived();
				Statistics.AddBytesReceived(size);
			}
			if (_ntpRequests.Count > 0 && _ntpRequests.TryGetValue(remoteEndPoint, out var _))
			{
				if (packet.Size >= 48)
				{
					byte[] array = new byte[packet.Size];
					Buffer.BlockCopy(packet.RawData, 0, array, 0, packet.Size);
					NtpPacket ntpPacket = NtpPacket.FromServerResponse(array, DateTime.UtcNow);
					try
					{
						ntpPacket.ValidateReply();
					}
					catch (InvalidOperationException)
					{
						ntpPacket = null;
					}
					if (ntpPacket != null)
					{
						_ntpRequests.TryRemove(remoteEndPoint, out var _);
						_ntpEventListener?.OnNtpResponse(ntpPacket);
					}
				}
				return;
			}
			if (_extraPacketLayer != null)
			{
				_extraPacketLayer.ProcessInboundPacket(ref remoteEndPoint, ref packet.RawData, ref packet.Size);
				if (packet.Size == 0)
				{
					return;
				}
			}
			if (!packet.Verify())
			{
				NetDebug.WriteError("[NM] DataReceived: bad!");
				PoolRecycle(packet);
				return;
			}
			switch (packet.Property)
			{
			case PacketProperty.ConnectRequest:
				if (NetConnectRequestPacket.GetProtocolId(packet) != 13)
				{
					SendRawAndRecycle(PoolGetWithProperty(PacketProperty.InvalidProtocol), remoteEndPoint);
					return;
				}
				break;
			case PacketProperty.Broadcast:
				if (BroadcastReceiveEnabled)
				{
					CreateEvent(NetEvent.EType.Broadcast, null, remoteEndPoint, SocketError.Success, 0, DisconnectReason.ConnectionFailed, null, DeliveryMethod.Unreliable, 0, packet);
				}
				return;
			case PacketProperty.UnconnectedMessage:
				if (UnconnectedMessagesEnabled)
				{
					CreateEvent(NetEvent.EType.ReceiveUnconnected, null, remoteEndPoint, SocketError.Success, 0, DisconnectReason.ConnectionFailed, null, DeliveryMethod.Unreliable, 0, packet);
				}
				return;
			case PacketProperty.NatMessage:
				if (NatPunchEnabled)
				{
					NatPunchModule.ProcessMessage(remoteEndPoint, packet);
				}
				return;
			}
			NetPeer actualValue = remoteEndPoint as NetPeer;
			bool flag = actualValue != null || TryGetPeer(remoteEndPoint, out actualValue);
			if (flag && EnableStatistics)
			{
				actualValue.Statistics.IncrementPacketsReceived();
				actualValue.Statistics.AddBytesReceived(size);
			}
			switch (packet.Property)
			{
			case PacketProperty.ConnectRequest:
			{
				NetConnectRequestPacket netConnectRequestPacket = NetConnectRequestPacket.FromData(packet);
				if (netConnectRequestPacket != null)
				{
					ProcessConnectRequest(remoteEndPoint, actualValue, netConnectRequestPacket);
				}
				break;
			}
			case PacketProperty.PeerNotFound:
				if (flag)
				{
					if (actualValue.ConnectionState == ConnectionState.Connected)
					{
						if (packet.Size == 1)
						{
							actualValue.ResetMtu();
							SendRaw(NetConnectAcceptPacket.MakeNetworkChanged(actualValue), remoteEndPoint);
						}
						else if (packet.Size == 2 && packet.RawData[1] == 1)
						{
							DisconnectPeerForce(actualValue, DisconnectReason.PeerNotFound, SocketError.Success, null);
						}
					}
				}
				else
				{
					if (packet.Size <= 1)
					{
						break;
					}
					bool flag2 = false;
					if (AllowPeerAddressChange)
					{
						NetConnectAcceptPacket netConnectAcceptPacket = NetConnectAcceptPacket.FromData(packet);
						if (netConnectAcceptPacket != null && netConnectAcceptPacket.PeerNetworkChanged && netConnectAcceptPacket.PeerId < _peersArray.Length)
						{
							_peersLock.EnterUpgradeableReadLock();
							NetPeer netPeer = _peersArray[netConnectAcceptPacket.PeerId];
							_peersLock.ExitUpgradeableReadLock();
							if (netPeer != null && netPeer.ConnectTime == netConnectAcceptPacket.ConnectionTime && netPeer.ConnectionNum == netConnectAcceptPacket.ConnectionNumber)
							{
								if (netPeer.ConnectionState == ConnectionState.Connected)
								{
									netPeer.InitiateEndPointChange();
									CreateEvent(NetEvent.EType.PeerAddressChanged, netPeer, remoteEndPoint, SocketError.Success, 0, DisconnectReason.ConnectionFailed, null, DeliveryMethod.Unreliable, 0);
								}
								flag2 = true;
							}
						}
					}
					PoolRecycle(packet);
					if (!flag2)
					{
						NetPacket netPacket = PoolGetWithProperty(PacketProperty.PeerNotFound, 1);
						netPacket.RawData[1] = 1;
						SendRawAndRecycle(netPacket, remoteEndPoint);
					}
				}
				break;
			case PacketProperty.InvalidProtocol:
				if (flag && actualValue.ConnectionState == ConnectionState.Outgoing)
				{
					DisconnectPeerForce(actualValue, DisconnectReason.InvalidProtocol, SocketError.Success, null);
				}
				break;
			case PacketProperty.Disconnect:
				if (flag)
				{
					DisconnectResult disconnectResult = actualValue.ProcessDisconnect(packet);
					if (disconnectResult == DisconnectResult.None)
					{
						PoolRecycle(packet);
						break;
					}
					DisconnectPeerForce(actualValue, (disconnectResult == DisconnectResult.Disconnect) ? DisconnectReason.RemoteConnectionClose : DisconnectReason.ConnectionRejected, SocketError.Success, packet);
				}
				else
				{
					PoolRecycle(packet);
				}
				SendRawAndRecycle(PoolGetWithProperty(PacketProperty.ShutdownOk), remoteEndPoint);
				break;
			case PacketProperty.ConnectAccept:
				if (flag)
				{
					NetConnectAcceptPacket netConnectAcceptPacket2 = NetConnectAcceptPacket.FromData(packet);
					if (netConnectAcceptPacket2 != null && actualValue.ProcessConnectAccept(netConnectAcceptPacket2))
					{
						CreateEvent(NetEvent.EType.Connect, actualValue, null, SocketError.Success, 0, DisconnectReason.ConnectionFailed, null, DeliveryMethod.Unreliable, 0);
					}
				}
				break;
			default:
				if (flag)
				{
					actualValue.ProcessPacket(packet);
				}
				else
				{
					SendRawAndRecycle(PoolGetWithProperty(PacketProperty.PeerNotFound), remoteEndPoint);
				}
				break;
			}
		}

		internal void CreateReceiveEvent(NetPacket packet, DeliveryMethod method, byte channelNumber, int headerSize, NetPeer fromPeer)
		{
			if (UnsyncedEvents || UnsyncedReceiveEvent || _manualMode)
			{
				NetEvent netEvent;
				lock (_eventLock)
				{
					netEvent = _netEventPoolHead;
					if (netEvent == null)
					{
						netEvent = new NetEvent(this);
					}
					else
					{
						_netEventPoolHead = netEvent.Next;
					}
				}
				netEvent.Next = null;
				netEvent.Type = NetEvent.EType.Receive;
				netEvent.DataReader.SetSource(packet, headerSize);
				netEvent.Peer = fromPeer;
				netEvent.DeliveryMethod = method;
				netEvent.ChannelNumber = channelNumber;
				ProcessEvent(netEvent);
				return;
			}
			lock (_eventLock)
			{
				NetEvent netEvent = _netEventPoolHead;
				if (netEvent == null)
				{
					netEvent = new NetEvent(this);
				}
				else
				{
					_netEventPoolHead = netEvent.Next;
				}
				netEvent.Next = null;
				netEvent.Type = NetEvent.EType.Receive;
				netEvent.DataReader.SetSource(packet, headerSize);
				netEvent.Peer = fromPeer;
				netEvent.DeliveryMethod = method;
				netEvent.ChannelNumber = channelNumber;
				if (_pendingEventTail == null)
				{
					_pendingEventHead = netEvent;
				}
				else
				{
					_pendingEventTail.Next = netEvent;
				}
				_pendingEventTail = netEvent;
			}
		}

		public void SendToAll(NetDataWriter writer, DeliveryMethod options)
		{
			SendToAll(writer.Data, 0, writer.Length, options);
		}

		public void SendToAll(byte[] data, DeliveryMethod options)
		{
			SendToAll(data, 0, data.Length, options);
		}

		public void SendToAll(byte[] data, int start, int length, DeliveryMethod options)
		{
			SendToAll(data, start, length, 0, options);
		}

		public void SendToAll(NetDataWriter writer, byte channelNumber, DeliveryMethod options)
		{
			SendToAll(writer.Data, 0, writer.Length, channelNumber, options);
		}

		public void SendToAll(byte[] data, byte channelNumber, DeliveryMethod options)
		{
			SendToAll(data, 0, data.Length, channelNumber, options);
		}

		public void SendToAll(byte[] data, int start, int length, byte channelNumber, DeliveryMethod options)
		{
			try
			{
				_peersLock.EnterReadLock();
				for (NetPeer netPeer = _headPeer; netPeer != null; netPeer = netPeer.NextPeer)
				{
					netPeer.Send(data, start, length, channelNumber, options);
				}
			}
			finally
			{
				_peersLock.ExitReadLock();
			}
		}

		public void SendToAll(NetDataWriter writer, DeliveryMethod options, NetPeer excludePeer)
		{
			SendToAll(writer.Data, 0, writer.Length, 0, options, excludePeer);
		}

		public void SendToAll(byte[] data, DeliveryMethod options, NetPeer excludePeer)
		{
			SendToAll(data, 0, data.Length, 0, options, excludePeer);
		}

		public void SendToAll(byte[] data, int start, int length, DeliveryMethod options, NetPeer excludePeer)
		{
			SendToAll(data, start, length, 0, options, excludePeer);
		}

		public void SendToAll(NetDataWriter writer, byte channelNumber, DeliveryMethod options, NetPeer excludePeer)
		{
			SendToAll(writer.Data, 0, writer.Length, channelNumber, options, excludePeer);
		}

		public void SendToAll(byte[] data, byte channelNumber, DeliveryMethod options, NetPeer excludePeer)
		{
			SendToAll(data, 0, data.Length, channelNumber, options, excludePeer);
		}

		public void SendToAll(byte[] data, int start, int length, byte channelNumber, DeliveryMethod options, NetPeer excludePeer)
		{
			try
			{
				_peersLock.EnterReadLock();
				for (NetPeer netPeer = _headPeer; netPeer != null; netPeer = netPeer.NextPeer)
				{
					if (netPeer != excludePeer)
					{
						netPeer.Send(data, start, length, channelNumber, options);
					}
				}
			}
			finally
			{
				_peersLock.ExitReadLock();
			}
		}

		public void SendToAll(ReadOnlySpan<byte> data, DeliveryMethod options)
		{
			SendToAll(data, 0, options, null);
		}

		public void SendToAll(ReadOnlySpan<byte> data, DeliveryMethod options, NetPeer excludePeer)
		{
			SendToAll(data, 0, options, excludePeer);
		}

		public void SendToAll(ReadOnlySpan<byte> data, byte channelNumber, DeliveryMethod options, NetPeer excludePeer)
		{
			try
			{
				_peersLock.EnterReadLock();
				for (NetPeer netPeer = _headPeer; netPeer != null; netPeer = netPeer.NextPeer)
				{
					if (netPeer != excludePeer)
					{
						netPeer.Send(data, channelNumber, options);
					}
				}
			}
			finally
			{
				_peersLock.ExitReadLock();
			}
		}

		public bool SendUnconnectedMessage(ReadOnlySpan<byte> message, IPEndPoint remoteEndPoint)
		{
			int headerSize = NetPacket.GetHeaderSize(PacketProperty.UnconnectedMessage);
			NetPacket netPacket = PoolGetPacket(message.Length + headerSize);
			netPacket.Property = PacketProperty.UnconnectedMessage;
			message.CopyTo(new Span<byte>(netPacket.RawData, headerSize, message.Length));
			return SendRawAndRecycle(netPacket, remoteEndPoint) > 0;
		}

		public bool Start()
		{
			return Start(0);
		}

		public bool Start(IPAddress addressIPv4, IPAddress addressIPv6, int port)
		{
			return Start(addressIPv4, addressIPv6, port, manualMode: false);
		}

		public bool Start(string addressIPv4, string addressIPv6, int port)
		{
			IPAddress addressIPv7 = NetUtils.ResolveAddress(addressIPv4);
			IPAddress addressIPv8 = NetUtils.ResolveAddress(addressIPv6);
			return Start(addressIPv7, addressIPv8, port);
		}

		public bool Start(int port)
		{
			return Start(IPAddress.Any, IPAddress.IPv6Any, port);
		}

		public bool StartInManualMode(IPAddress addressIPv4, IPAddress addressIPv6, int port)
		{
			return Start(addressIPv4, addressIPv6, port, manualMode: true);
		}

		public bool StartInManualMode(string addressIPv4, string addressIPv6, int port)
		{
			IPAddress addressIPv7 = NetUtils.ResolveAddress(addressIPv4);
			IPAddress addressIPv8 = NetUtils.ResolveAddress(addressIPv6);
			return StartInManualMode(addressIPv7, addressIPv8, port);
		}

		public bool StartInManualMode(int port)
		{
			return StartInManualMode(IPAddress.Any, IPAddress.IPv6Any, port);
		}

		public bool SendUnconnectedMessage(byte[] message, IPEndPoint remoteEndPoint)
		{
			return SendUnconnectedMessage(message, 0, message.Length, remoteEndPoint);
		}

		public bool SendUnconnectedMessage(NetDataWriter writer, string address, int port)
		{
			IPEndPoint remoteEndPoint = NetUtils.MakeEndPoint(address, port);
			return SendUnconnectedMessage(writer.Data, 0, writer.Length, remoteEndPoint);
		}

		public bool SendUnconnectedMessage(NetDataWriter writer, IPEndPoint remoteEndPoint)
		{
			return SendUnconnectedMessage(writer.Data, 0, writer.Length, remoteEndPoint);
		}

		public bool SendUnconnectedMessage(byte[] message, int start, int length, IPEndPoint remoteEndPoint)
		{
			NetPacket packet = PoolGetWithData(PacketProperty.UnconnectedMessage, message, start, length);
			return SendRawAndRecycle(packet, remoteEndPoint) > 0;
		}

		public void TriggerUpdate()
		{
			_updateTriggerEvent.Set();
		}

		public void PollEvents(int maxProcessedEvents = 0)
		{
			if (_manualMode)
			{
				if (_udpSocketv4 != null)
				{
					ManualReceive(_udpSocketv4, _bufferEndPointv4, maxProcessedEvents);
				}
				if (_udpSocketv6 != null && _udpSocketv6 != _udpSocketv4)
				{
					ManualReceive(_udpSocketv6, _bufferEndPointv6, maxProcessedEvents);
				}
			}
			else
			{
				if (UnsyncedEvents)
				{
					return;
				}
				NetEvent netEvent;
				lock (_eventLock)
				{
					netEvent = _pendingEventHead;
					_pendingEventHead = null;
					_pendingEventTail = null;
				}
				int num = 0;
				while (netEvent != null)
				{
					NetEvent next = netEvent.Next;
					ProcessEvent(netEvent);
					netEvent = next;
					num++;
					if (num == maxProcessedEvents)
					{
						break;
					}
				}
			}
		}

		public NetPeer Connect(string address, int port, string key)
		{
			return Connect(address, port, NetDataWriter.FromString(key));
		}

		public NetPeer Connect(string address, int port, NetDataWriter connectionData)
		{
			IPEndPoint target;
			try
			{
				target = NetUtils.MakeEndPoint(address, port);
			}
			catch
			{
				CreateEvent(NetEvent.EType.Disconnect, null, null, SocketError.Success, 0, DisconnectReason.UnknownHost, null, DeliveryMethod.Unreliable, 0);
				return null;
			}
			return Connect(target, connectionData);
		}

		public NetPeer Connect(IPEndPoint target, string key)
		{
			return Connect(target, NetDataWriter.FromString(key));
		}

		public NetPeer Connect(IPEndPoint target, NetDataWriter connectionData)
		{
			if (!IsRunning)
			{
				throw new InvalidOperationException("Client is not running");
			}
			lock (_requestsDict)
			{
				if (_requestsDict.ContainsKey(target))
				{
					return null;
				}
				byte connectNum = 0;
				if (TryGetPeer(target, out var actualValue))
				{
					ConnectionState connectionState = actualValue.ConnectionState;
					if (connectionState == ConnectionState.Outgoing || connectionState == ConnectionState.Connected)
					{
						return actualValue;
					}
					connectNum = (byte)((actualValue.ConnectionNum + 1) % 4);
					RemovePeer(actualValue, enableWriteLock: true);
				}
				actualValue = new NetPeer(this, target, GetNextPeerId(), connectNum, connectionData);
				AddPeer(actualValue);
				return actualValue;
			}
		}

		public void Stop()
		{
			Stop(sendDisconnectMessages: true);
		}

		public void Stop(bool sendDisconnectMessages)
		{
			if (IsRunning)
			{
				for (NetPeer netPeer = _headPeer; netPeer != null; netPeer = netPeer.NextPeer)
				{
					netPeer.Shutdown(null, 0, 0, !sendDisconnectMessages);
				}
				CloseSocket();
				_updateTriggerEvent.Set();
				if (!_manualMode)
				{
					_logicThread.Join();
					_logicThread = null;
				}
				ClearPeerSet();
				_peerIds = new ConcurrentQueue<int>();
				_lastPeerId = 0;
				_connectedPeersCount = 0L;
				_pendingEventHead = null;
				_pendingEventTail = null;
			}
		}

		[Conditional("DEBUG")]
		private void ClearPingSimulationList()
		{
			lock (_pingSimulationList)
			{
				_pingSimulationList.Clear();
			}
		}

		public int GetPeersCount(ConnectionState peerState)
		{
			int num = 0;
			_peersLock.EnterReadLock();
			for (NetPeer netPeer = _headPeer; netPeer != null; netPeer = netPeer.NextPeer)
			{
				if ((netPeer.ConnectionState & peerState) != 0)
				{
					num++;
				}
			}
			_peersLock.ExitReadLock();
			return num;
		}

		public void GetPeersNonAlloc(List<NetPeer> peers, ConnectionState peerState)
		{
			peers.Clear();
			_peersLock.EnterReadLock();
			for (NetPeer netPeer = _headPeer; netPeer != null; netPeer = netPeer.NextPeer)
			{
				if ((netPeer.ConnectionState & peerState) != 0)
				{
					peers.Add(netPeer);
				}
			}
			_peersLock.ExitReadLock();
		}

		public void DisconnectAll()
		{
			DisconnectAll(null, 0, 0);
		}

		public void DisconnectAll(byte[] data, int start, int count)
		{
			_peersLock.EnterReadLock();
			for (NetPeer netPeer = _headPeer; netPeer != null; netPeer = netPeer.NextPeer)
			{
				DisconnectPeer(netPeer, DisconnectReason.DisconnectPeerCalled, SocketError.Success, force: false, data, start, count, null);
			}
			_peersLock.ExitReadLock();
		}

		public void DisconnectPeerForce(NetPeer peer)
		{
			DisconnectPeerForce(peer, DisconnectReason.DisconnectPeerCalled, SocketError.Success, null);
		}

		public void DisconnectPeer(NetPeer peer)
		{
			DisconnectPeer(peer, null, 0, 0);
		}

		public void DisconnectPeer(NetPeer peer, byte[] data)
		{
			DisconnectPeer(peer, data, 0, data.Length);
		}

		public void DisconnectPeer(NetPeer peer, NetDataWriter writer)
		{
			DisconnectPeer(peer, writer.Data, 0, writer.Length);
		}

		public void DisconnectPeer(NetPeer peer, byte[] data, int start, int count)
		{
			DisconnectPeer(peer, DisconnectReason.DisconnectPeerCalled, SocketError.Success, force: false, data, start, count, null);
		}

		public void CreateNtpRequest(IPEndPoint endPoint)
		{
			_ntpRequests.TryAdd(endPoint, new NtpRequest(endPoint));
		}

		public void CreateNtpRequest(string ntpServerAddress, int port)
		{
			IPEndPoint iPEndPoint = NetUtils.MakeEndPoint(ntpServerAddress, port);
			_ntpRequests.TryAdd(iPEndPoint, new NtpRequest(iPEndPoint));
		}

		public void CreateNtpRequest(string ntpServerAddress)
		{
			IPEndPoint iPEndPoint = NetUtils.MakeEndPoint(ntpServerAddress, 123);
			_ntpRequests.TryAdd(iPEndPoint, new NtpRequest(iPEndPoint));
		}

		public NetPeerEnumerator GetEnumerator()
		{
			return new NetPeerEnumerator(_headPeer);
		}

		IEnumerator<NetPeer> IEnumerable<NetPeer>.GetEnumerator()
		{
			return new NetPeerEnumerator(_headPeer);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new NetPeerEnumerator(_headPeer);
		}

		private static int HashSetGetPrime(int min)
		{
			int[] primes = Primes;
			foreach (int num in primes)
			{
				if (num >= min)
				{
					return num;
				}
			}
			for (int j = min | 1; j < int.MaxValue; j += 2)
			{
				if (IsPrime(j) && (j - 1) % 101 != 0)
				{
					return j;
				}
			}
			return min;
			static bool IsPrime(int candidate)
			{
				if (((uint)candidate & (true ? 1u : 0u)) != 0)
				{
					int num2 = (int)Math.Sqrt(candidate);
					for (int k = 3; k <= num2; k += 2)
					{
						if (candidate % k == 0)
						{
							return false;
						}
					}
					return true;
				}
				return candidate == 2;
			}
		}

		private void ClearPeerSet()
		{
			_peersLock.EnterWriteLock();
			_headPeer = null;
			if (_lastIndex > 0)
			{
				Array.Clear(_slots, 0, _lastIndex);
				Array.Clear(_buckets, 0, _buckets.Length);
				_lastIndex = 0;
				_count = 0;
				_freeList = -1;
			}
			_peersArray = new NetPeer[32];
			_peersLock.ExitWriteLock();
		}

		private bool ContainsPeer(NetPeer item)
		{
			if (item == null)
			{
				NetDebug.WriteError($"Contains peer null: {item}");
				return false;
			}
			if (_buckets != null)
			{
				int num = item.GetHashCode() & 0x7FFFFFFF;
				for (int num2 = _buckets[num % _buckets.Length] - 1; num2 >= 0; num2 = _slots[num2].Next)
				{
					if (_slots[num2].HashCode == num && _slots[num2].Value.Equals(item))
					{
						return true;
					}
				}
			}
			return false;
		}

		public NetPeer GetPeerById(int id)
		{
			if (id < 0 || id >= _peersArray.Length)
			{
				return null;
			}
			return _peersArray[id];
		}

		public bool TryGetPeerById(int id, out NetPeer peer)
		{
			peer = GetPeerById(id);
			return peer != null;
		}

		private void AddPeer(NetPeer peer)
		{
			if (peer == null)
			{
				NetDebug.WriteError($"Add peer null: {peer}");
				return;
			}
			_peersLock.EnterWriteLock();
			if (_headPeer != null)
			{
				peer.NextPeer = _headPeer;
				_headPeer.PrevPeer = peer;
			}
			_headPeer = peer;
			AddPeerToSet(peer);
			if (peer.Id >= _peersArray.Length)
			{
				int num = _peersArray.Length * 2;
				while (peer.Id >= num)
				{
					num *= 2;
				}
				Array.Resize(ref _peersArray, num);
			}
			_peersArray[peer.Id] = peer;
			_peersLock.ExitWriteLock();
		}

		private void RemovePeer(NetPeer peer, bool enableWriteLock)
		{
			if (enableWriteLock)
			{
				_peersLock.EnterWriteLock();
			}
			if (!RemovePeerFromSet(peer))
			{
				if (enableWriteLock)
				{
					_peersLock.ExitWriteLock();
				}
				return;
			}
			if (peer == _headPeer)
			{
				_headPeer = peer.NextPeer;
			}
			if (peer.PrevPeer != null)
			{
				peer.PrevPeer.NextPeer = peer.NextPeer;
			}
			if (peer.NextPeer != null)
			{
				peer.NextPeer.PrevPeer = peer.PrevPeer;
			}
			peer.PrevPeer = null;
			_peersArray[peer.Id] = null;
			_peerIds.Enqueue(peer.Id);
			if (enableWriteLock)
			{
				_peersLock.ExitWriteLock();
			}
		}

		private bool RemovePeerFromSet(NetPeer peer)
		{
			if (_buckets == null || peer == null)
			{
				return false;
			}
			int num = peer.GetHashCode() & 0x7FFFFFFF;
			int num2 = num % _buckets.Length;
			int num3 = -1;
			for (int num4 = _buckets[num2] - 1; num4 >= 0; num4 = _slots[num4].Next)
			{
				if (_slots[num4].HashCode == num && _slots[num4].Value.Equals(peer))
				{
					if (num3 < 0)
					{
						_buckets[num2] = _slots[num4].Next + 1;
					}
					else
					{
						_slots[num3].Next = _slots[num4].Next;
					}
					_slots[num4].HashCode = -1;
					_slots[num4].Value = null;
					_slots[num4].Next = _freeList;
					_count--;
					if (_count == 0)
					{
						_lastIndex = 0;
						_freeList = -1;
					}
					else
					{
						_freeList = num4;
					}
					return true;
				}
				num3 = num4;
			}
			return false;
		}

		private bool TryGetPeer(IPEndPoint endPoint, out NetPeer actualValue)
		{
			if (_buckets != null)
			{
				int num = endPoint.GetHashCode() & 0x7FFFFFFF;
				_peersLock.EnterReadLock();
				for (int num2 = _buckets[num % _buckets.Length] - 1; num2 >= 0; num2 = _slots[num2].Next)
				{
					if (_slots[num2].HashCode == num && _slots[num2].Value.Equals(endPoint))
					{
						actualValue = _slots[num2].Value;
						_peersLock.ExitReadLock();
						return true;
					}
				}
				_peersLock.ExitReadLock();
			}
			actualValue = null;
			return false;
		}

		private bool TryGetPeer(SocketAddress saddr, out NetPeer actualValue)
		{
			if (_buckets != null)
			{
				int num = saddr.GetHashCode() & 0x7FFFFFFF;
				_peersLock.EnterReadLock();
				for (int num2 = _buckets[num % _buckets.Length] - 1; num2 >= 0; num2 = _slots[num2].Next)
				{
					if (_slots[num2].HashCode == num && _slots[num2].Value.Serialize().Equals(saddr))
					{
						actualValue = _slots[num2].Value;
						_peersLock.ExitReadLock();
						return true;
					}
				}
				_peersLock.ExitReadLock();
			}
			actualValue = null;
			return false;
		}

		private bool AddPeerToSet(NetPeer value)
		{
			if (_buckets == null)
			{
				int num = HashSetGetPrime(0);
				_buckets = new int[num];
				_slots = new Slot[num];
			}
			int num2 = value.GetHashCode() & 0x7FFFFFFF;
			int num3 = num2 % _buckets.Length;
			for (int num4 = _buckets[num2 % _buckets.Length] - 1; num4 >= 0; num4 = _slots[num4].Next)
			{
				if (_slots[num4].HashCode == num2 && _slots[num4].Value.Equals(value))
				{
					return false;
				}
			}
			int num5;
			if (_freeList >= 0)
			{
				num5 = _freeList;
				_freeList = _slots[num5].Next;
			}
			else
			{
				if (_lastIndex == _slots.Length)
				{
					int num6 = 2 * _count;
					num6 = (((uint)num6 > 2147483587u && 2147483587 > _count) ? 2147483587 : HashSetGetPrime(num6));
					Slot[] array = new Slot[num6];
					Array.Copy(_slots, 0, array, 0, _lastIndex);
					_buckets = new int[num6];
					for (int i = 0; i < _lastIndex; i++)
					{
						int num7 = array[i].HashCode % num6;
						array[i].Next = _buckets[num7] - 1;
						_buckets[num7] = i + 1;
					}
					_slots = array;
					num3 = num2 % _buckets.Length;
				}
				num5 = _lastIndex;
				_lastIndex++;
			}
			_slots[num5].HashCode = num2;
			_slots[num5].Value = value;
			_slots[num5].Next = _buckets[num3] - 1;
			_buckets[num3] = num5 + 1;
			_count++;
			return true;
		}

		private NetPacket PoolGetWithData(PacketProperty property, byte[] data, int start, int length)
		{
			int headerSize = NetPacket.GetHeaderSize(property);
			NetPacket netPacket = PoolGetPacket(length + headerSize);
			netPacket.Property = property;
			Buffer.BlockCopy(data, start, netPacket.RawData, headerSize, length);
			return netPacket;
		}

		private NetPacket PoolGetWithProperty(PacketProperty property, int size)
		{
			NetPacket netPacket = PoolGetPacket(size + NetPacket.GetHeaderSize(property));
			netPacket.Property = property;
			return netPacket;
		}

		private NetPacket PoolGetWithProperty(PacketProperty property)
		{
			NetPacket netPacket = PoolGetPacket(NetPacket.GetHeaderSize(property));
			netPacket.Property = property;
			return netPacket;
		}

		internal NetPacket PoolGetPacket(int size)
		{
			if (size > NetConstants.MaxPacketSize)
			{
				return new NetPacket(size);
			}
			NetPacket poolHead;
			lock (_poolLock)
			{
				poolHead = _poolHead;
				if (poolHead == null)
				{
					return new NetPacket(size);
				}
				_poolHead = _poolHead.Next;
				_poolCount--;
			}
			poolHead.Size = size;
			if (poolHead.RawData.Length < size)
			{
				poolHead.RawData = new byte[size];
			}
			return poolHead;
		}

		internal void PoolRecycle(NetPacket packet)
		{
			if (packet.RawData.Length > NetConstants.MaxPacketSize || _poolCount >= PacketPoolSize)
			{
				return;
			}
			packet.RawData[0] = 0;
			lock (_poolLock)
			{
				packet.Next = _poolHead;
				_poolHead = packet;
				_poolCount++;
			}
		}

		static NetManager()
		{
			Primes = new int[72]
			{
				3, 7, 11, 17, 23, 29, 37, 47, 59, 71,
				89, 107, 131, 163, 197, 239, 293, 353, 431, 521,
				631, 761, 919, 1103, 1327, 1597, 1931, 2333, 2801, 3371,
				4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591, 17519, 21023,
				25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363,
				156437, 187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403,
				968897, 1162687, 1395263, 1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559,
				5999471, 7199369
			};
			MulticastAddressV6 = IPAddress.Parse("ff02::1");
			IPv6Support = System.Net.Sockets.Socket.OSSupportsIPv6;
		}

		private bool ProcessError(SocketException ex)
		{
			switch (ex.SocketErrorCode)
			{
			case SocketError.NotConnected:
				NotConnected = true;
				return true;
			case SocketError.OperationAborted:
			case SocketError.Interrupted:
			case SocketError.NotSocket:
				return true;
			default:
				NetDebug.WriteError($"[R]Error code: {ex.SocketErrorCode} - {ex}");
				CreateEvent(NetEvent.EType.Error, null, null, ex.SocketErrorCode, 0, DisconnectReason.ConnectionFailed, null, DeliveryMethod.Unreliable, 0);
				break;
			case SocketError.WouldBlock:
			case SocketError.MessageSize:
			case SocketError.NetworkReset:
			case SocketError.ConnectionReset:
			case SocketError.TimedOut:
				break;
			}
			return false;
		}

		private void ManualReceive(System.Net.Sockets.Socket socket, EndPoint bufferEndPoint, int maxReceive)
		{
			try
			{
				int num = 0;
				while (socket.Available > 0)
				{
					ReceiveFrom(socket, ref bufferEndPoint);
					num++;
					if (num == maxReceive)
					{
						break;
					}
				}
			}
			catch (SocketException ex)
			{
				ProcessError(ex);
			}
			catch (ObjectDisposedException)
			{
			}
			catch (Exception ex3)
			{
				NetDebug.WriteError("[NM] SocketReceiveThread error: " + ex3);
			}
		}

		private void NativeReceiveLogic()
		{
			IntPtr handle = _udpSocketv4.Handle;
			IntPtr s2 = _udpSocketv6?.Handle ?? IntPtr.Zero;
			byte[] address2 = new byte[16];
			byte[] address3 = new byte[28];
			IPEndPoint tempEndPoint = new IPEndPoint(IPAddress.Any, 0);
			List<System.Net.Sockets.Socket> list = new List<System.Net.Sockets.Socket>(2);
			System.Net.Sockets.Socket udpSocketv = _udpSocketv4;
			System.Net.Sockets.Socket udpSocketv2 = _udpSocketv6;
			NetPacket packet = PoolGetPacket(NetConstants.MaxPacketSize);
			while (IsRunning)
			{
				try
				{
					if (udpSocketv2 == null)
					{
						if (!NativeReceiveFrom(handle, address2))
						{
							break;
						}
						continue;
					}
					bool flag = false;
					if (udpSocketv.Available != 0 || list.Contains(udpSocketv))
					{
						if (!NativeReceiveFrom(handle, address2))
						{
							break;
						}
						flag = true;
					}
					if (udpSocketv2.Available != 0 || list.Contains(udpSocketv2))
					{
						if (!NativeReceiveFrom(s2, address3))
						{
							break;
						}
						flag = true;
					}
					list.Clear();
					if (!flag)
					{
						list.Add(udpSocketv);
						list.Add(udpSocketv2);
						System.Net.Sockets.Socket.Select(list, null, null, 500000);
					}
				}
				catch (SocketException ex)
				{
					if (ProcessError(ex))
					{
						break;
					}
				}
				catch (ObjectDisposedException)
				{
					break;
				}
				catch (ThreadAbortException)
				{
					break;
				}
				catch (Exception ex4)
				{
					NetDebug.WriteError("[NM] SocketReceiveThread error: " + ex4);
				}
			}
			bool NativeReceiveFrom(IntPtr s, byte[] address)
			{
				int socketAddressSize = address.Length;
				packet.Size = NativeSocket.RecvFrom(s, packet.RawData, NetConstants.MaxPacketSize, address, ref socketAddressSize);
				if (packet.Size == 0)
				{
					return true;
				}
				if (packet.Size == -1)
				{
					return !ProcessError(new SocketException((int)NativeSocket.GetSocketError()));
				}
				short num = (short)((address[1] << 8) | address[0]);
				tempEndPoint.Port = (ushort)((address[2] << 8) | address[3]);
				if ((NativeSocket.UnixMode && num == 10) || (!NativeSocket.UnixMode && num == 23))
				{
					uint num2 = (uint)((address[27] << 24) + (address[26] << 16) + (address[25] << 8) + address[24]);
					tempEndPoint.Address = new IPAddress(new ReadOnlySpan<byte>(address, 8, 16), num2);
				}
				else
				{
					long newAddress = (uint)((address[4] & 0xFF) | ((address[5] << 8) & 0xFF00) | ((address[6] << 16) & 0xFF0000) | (address[7] << 24));
					tempEndPoint.Address = new IPAddress(newAddress);
				}
				if (TryGetPeer(tempEndPoint, out var actualValue))
				{
					OnMessageReceived(packet, actualValue);
				}
				else
				{
					OnMessageReceived(packet, tempEndPoint);
					tempEndPoint = new IPEndPoint(IPAddress.Any, 0);
				}
				packet = PoolGetPacket(NetConstants.MaxPacketSize);
				return true;
			}
		}

		private void ReceiveFrom(System.Net.Sockets.Socket s, ref EndPoint bufferEndPoint)
		{
			NetPacket netPacket = PoolGetPacket(NetConstants.MaxPacketSize);
			netPacket.Size = s.ReceiveFrom(netPacket.RawData, 0, NetConstants.MaxPacketSize, SocketFlags.None, ref bufferEndPoint);
			OnMessageReceived(netPacket, (IPEndPoint)bufferEndPoint);
		}

		private void ReceiveLogic()
		{
			EndPoint bufferEndPoint = new IPEndPoint(IPAddress.Any, 0);
			EndPoint bufferEndPoint2 = new IPEndPoint(IPAddress.IPv6Any, 0);
			List<System.Net.Sockets.Socket> list = new List<System.Net.Sockets.Socket>(2);
			System.Net.Sockets.Socket udpSocketv = _udpSocketv4;
			System.Net.Sockets.Socket udpSocketv2 = _udpSocketv6;
			while (IsRunning)
			{
				try
				{
					if (udpSocketv2 == null)
					{
						if (udpSocketv.Available != 0 || udpSocketv.Poll(500000, SelectMode.SelectRead))
						{
							ReceiveFrom(udpSocketv, ref bufferEndPoint);
						}
						continue;
					}
					bool flag = false;
					if (udpSocketv.Available != 0 || list.Contains(udpSocketv))
					{
						ReceiveFrom(udpSocketv, ref bufferEndPoint);
						flag = true;
					}
					if (udpSocketv2.Available != 0 || list.Contains(udpSocketv2))
					{
						ReceiveFrom(udpSocketv2, ref bufferEndPoint2);
						flag = true;
					}
					list.Clear();
					if (!flag)
					{
						list.Add(udpSocketv);
						list.Add(udpSocketv2);
						System.Net.Sockets.Socket.Select(list, null, null, 500000);
					}
				}
				catch (SocketException ex)
				{
					if (ProcessError(ex))
					{
						break;
					}
				}
				catch (ObjectDisposedException)
				{
					break;
				}
				catch (ThreadAbortException)
				{
					break;
				}
				catch (Exception ex4)
				{
					NetDebug.WriteError("[NM] SocketReceiveThread error: " + ex4);
				}
			}
		}

		public bool Start(IPAddress addressIPv4, IPAddress addressIPv6, int port, bool manualMode)
		{
			if (IsRunning && !NotConnected)
			{
				return false;
			}
			NotConnected = false;
			_manualMode = manualMode;
			UseNativeSockets = UseNativeSockets && NativeSocket.IsSupported;
			_udpSocketv4 = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
			if (!BindSocket(_udpSocketv4, new IPEndPoint(addressIPv4, port)))
			{
				return false;
			}
			LocalPort = ((IPEndPoint)_udpSocketv4.LocalEndPoint).Port;
			IsRunning = true;
			if (_manualMode)
			{
				_bufferEndPointv4 = new IPEndPoint(IPAddress.Any, 0);
			}
			if (IPv6Support && IPv6Enabled)
			{
				_udpSocketv6 = new System.Net.Sockets.Socket(AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp);
				if (BindSocket(_udpSocketv6, new IPEndPoint(addressIPv6, LocalPort)))
				{
					if (_manualMode)
					{
						_bufferEndPointv6 = new IPEndPoint(IPAddress.IPv6Any, 0);
					}
				}
				else
				{
					_udpSocketv6 = null;
				}
			}
			if (!manualMode)
			{
				ThreadStart start = ReceiveLogic;
				if (UseNativeSockets)
				{
					start = NativeReceiveLogic;
				}
				_receiveThread = new Thread(start)
				{
					Name = $"ReceiveThread({LocalPort})",
					IsBackground = true
				};
				_receiveThread.Start();
				if (_logicThread == null)
				{
					_logicThread = new Thread(UpdateLogic)
					{
						Name = "LogicThread",
						IsBackground = true
					};
					_logicThread.Start();
				}
			}
			return true;
		}

		private bool BindSocket(System.Net.Sockets.Socket socket, IPEndPoint ep)
		{
			socket.ReceiveTimeout = 500;
			socket.SendTimeout = 500;
			socket.ReceiveBufferSize = 1048576;
			socket.SendBufferSize = 1048576;
			socket.Blocking = true;
			if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
			{
				try
				{
					socket.IOControl(-1744830452, new byte[1], null);
				}
				catch
				{
				}
			}
			try
			{
				socket.ExclusiveAddressUse = !ReuseAddress;
				socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, ReuseAddress);
				socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontRoute, DontRoute);
			}
			catch
			{
			}
			if (ep.AddressFamily == AddressFamily.InterNetwork)
			{
				Ttl = 255;
				try
				{
					socket.EnableBroadcast = true;
				}
				catch (SocketException ex)
				{
					NetDebug.WriteError($"[B]Broadcast error: {ex.SocketErrorCode}");
				}
				if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
				{
					try
					{
						socket.DontFragment = true;
					}
					catch (SocketException ex2)
					{
						NetDebug.WriteError($"[B]DontFragment error: {ex2.SocketErrorCode}");
					}
				}
			}
			try
			{
				socket.Bind(ep);
				if (ep.AddressFamily == AddressFamily.InterNetworkV6)
				{
					try
					{
						socket.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.AddMembership, new IPv6MulticastOption(MulticastAddressV6));
					}
					catch (Exception)
					{
					}
				}
			}
			catch (SocketException ex4)
			{
				switch (ex4.SocketErrorCode)
				{
				case SocketError.AddressAlreadyInUse:
					if (socket.AddressFamily == AddressFamily.InterNetworkV6)
					{
						try
						{
							socket.DualMode = false;
							socket.Bind(ep);
						}
						catch (SocketException ex5)
						{
							NetDebug.WriteError($"[B]Bind exception: {ex5}, errorCode: {ex5.SocketErrorCode}");
							return false;
						}
						return true;
					}
					break;
				case SocketError.AddressFamilyNotSupported:
					return true;
				}
				NetDebug.WriteError($"[B]Bind exception: {ex4}, errorCode: {ex4.SocketErrorCode}");
				return false;
			}
			return true;
		}

		internal int SendRawAndRecycle(NetPacket packet, IPEndPoint remoteEndPoint)
		{
			int result = SendRaw(packet.RawData, 0, packet.Size, remoteEndPoint);
			PoolRecycle(packet);
			return result;
		}

		internal int SendRaw(NetPacket packet, IPEndPoint remoteEndPoint)
		{
			return SendRaw(packet.RawData, 0, packet.Size, remoteEndPoint);
		}

		internal unsafe int SendRaw(byte[] message, int start, int length, IPEndPoint remoteEndPoint)
		{
			if (!IsRunning)
			{
				return 0;
			}
			NetPacket netPacket = null;
			if (_extraPacketLayer != null)
			{
				netPacket = PoolGetPacket(length + _extraPacketLayer.ExtraPacketSizeForLayer);
				Buffer.BlockCopy(message, start, netPacket.RawData, 0, length);
				start = 0;
				_extraPacketLayer.ProcessOutBoundPacket(ref remoteEndPoint, ref netPacket.RawData, ref start, ref length);
				message = netPacket.RawData;
			}
			System.Net.Sockets.Socket socket = _udpSocketv4;
			if (remoteEndPoint.AddressFamily == AddressFamily.InterNetworkV6 && IPv6Support)
			{
				socket = _udpSocketv6;
				if (socket == null)
				{
					return 0;
				}
			}
			int num;
			try
			{
				if (UseNativeSockets && remoteEndPoint is NetPeer netPeer)
				{
					fixed (byte* pinnedBuffer = &message[start])
					{
						num = NativeSocket.SendTo(socket.Handle, pinnedBuffer, length, netPeer.NativeAddress, netPeer.NativeAddress.Length);
					}
					if (num == -1)
					{
						throw NativeSocket.GetSocketException();
					}
				}
				else
				{
					num = socket.SendTo(message, start, length, SocketFlags.None, remoteEndPoint);
				}
			}
			catch (SocketException ex)
			{
				switch (ex.SocketErrorCode)
				{
				case SocketError.Interrupted:
				case SocketError.NoBufferSpaceAvailable:
					return 0;
				case SocketError.MessageSize:
					return 0;
				case SocketError.NetworkUnreachable:
				case SocketError.HostUnreachable:
					if (DisconnectOnUnreachable && remoteEndPoint is NetPeer peer)
					{
						DisconnectPeerForce(peer, (ex.SocketErrorCode == SocketError.HostUnreachable) ? DisconnectReason.HostUnreachable : DisconnectReason.NetworkUnreachable, ex.SocketErrorCode, null);
					}
					CreateEvent(NetEvent.EType.Error, null, remoteEndPoint, ex.SocketErrorCode, 0, DisconnectReason.ConnectionFailed, null, DeliveryMethod.Unreliable, 0);
					return -1;
				case SocketError.Shutdown:
					CreateEvent(NetEvent.EType.Error, null, remoteEndPoint, ex.SocketErrorCode, 0, DisconnectReason.ConnectionFailed, null, DeliveryMethod.Unreliable, 0);
					return -1;
				default:
					NetDebug.WriteError($"[S] {ex}");
					return -1;
				}
			}
			catch (Exception value)
			{
				NetDebug.WriteError($"[S] {value}");
				return 0;
			}
			finally
			{
				if (netPacket != null)
				{
					PoolRecycle(netPacket);
				}
			}
			if (num <= 0)
			{
				return 0;
			}
			if (EnableStatistics)
			{
				Statistics.IncrementPacketsSent();
				Statistics.AddBytesSent(length);
			}
			return num;
		}

		public bool SendBroadcast(NetDataWriter writer, int port)
		{
			return SendBroadcast(writer.Data, 0, writer.Length, port);
		}

		public bool SendBroadcast(byte[] data, int port)
		{
			return SendBroadcast(data, 0, data.Length, port);
		}

		public bool SendBroadcast(byte[] data, int start, int length, int port)
		{
			if (!IsRunning)
			{
				return false;
			}
			NetPacket netPacket;
			if (_extraPacketLayer != null)
			{
				int headerSize = NetPacket.GetHeaderSize(PacketProperty.Broadcast);
				netPacket = PoolGetPacket(headerSize + length + _extraPacketLayer.ExtraPacketSizeForLayer);
				netPacket.Property = PacketProperty.Broadcast;
				Buffer.BlockCopy(data, start, netPacket.RawData, headerSize, length);
				int offset = 0;
				int length2 = length + headerSize;
				IPEndPoint endPoint = null;
				_extraPacketLayer.ProcessOutBoundPacket(ref endPoint, ref netPacket.RawData, ref offset, ref length2);
			}
			else
			{
				netPacket = PoolGetWithData(PacketProperty.Broadcast, data, start, length);
			}
			bool flag = false;
			bool flag2 = false;
			try
			{
				flag = _udpSocketv4.SendTo(netPacket.RawData, 0, netPacket.Size, SocketFlags.None, new IPEndPoint(IPAddress.Broadcast, port)) > 0;
				if (_udpSocketv6 != null)
				{
					flag2 = _udpSocketv6.SendTo(netPacket.RawData, 0, netPacket.Size, SocketFlags.None, new IPEndPoint(MulticastAddressV6, port)) > 0;
				}
			}
			catch (SocketException ex)
			{
				if (ex.SocketErrorCode == SocketError.HostUnreachable)
				{
					return flag;
				}
				NetDebug.WriteError($"[S][MCAST] {ex}");
				return flag;
			}
			catch (Exception value)
			{
				NetDebug.WriteError($"[S][MCAST] {value}");
				return flag;
			}
			finally
			{
				PoolRecycle(netPacket);
			}
			return flag || flag2;
		}

		private void CloseSocket()
		{
			IsRunning = false;
			_udpSocketv4?.Close();
			_udpSocketv6?.Close();
			_udpSocketv4 = null;
			_udpSocketv6 = null;
			if (_receiveThread != null && _receiveThread != Thread.CurrentThread)
			{
				_receiveThread.Join();
			}
			_receiveThread = null;
		}
	}
	internal enum PacketProperty : byte
	{
		Unreliable,
		Channeled,
		Ack,
		Ping,
		Pong,
		ConnectRequest,
		ConnectAccept,
		Disconnect,
		UnconnectedMessage,
		MtuCheck,
		MtuOk,
		Broadcast,
		Merged,
		ShutdownOk,
		PeerNotFound,
		InvalidProtocol,
		NatMessage,
		Empty
	}
	internal sealed class NetPacket
	{
		private static readonly int PropertiesCount;

		private static readonly int[] HeaderSizes;

		public byte[] RawData;

		public int Size;

		public object UserData;

		public NetPacket Next;

		public PacketProperty Property
		{
			get
			{
				return (PacketProperty)(RawData[0] & 0x1Fu);
			}
			set
			{
				RawData[0] = (byte)((RawData[0] & 0xE0u) | (uint)value);
			}
		}

		public byte ConnectionNumber
		{
			get
			{
				return (byte)((RawData[0] & 0x60) >> 5);
			}
			set
			{
				RawData[0] = (byte)((RawData[0] & 0x9Fu) | (uint)(value << 5));
			}
		}

		public ushort Sequence
		{
			get
			{
				return BitConverter.ToUInt16(RawData, 1);
			}
			set
			{
				FastBitConverter.GetBytes(RawData, 1, value);
			}
		}

		public bool IsFragmented => (RawData[0] & 0x80) != 0;

		public byte ChannelId
		{
			get
			{
				return RawData[3];
			}
			set
			{
				RawData[3] = value;
			}
		}

		public ushort FragmentId
		{
			get
			{
				return BitConverter.ToUInt16(RawData, 4);
			}
			set
			{
				FastBitConverter.GetBytes(RawData, 4, value);
			}
		}

		public ushort FragmentPart
		{
			get
			{
				return BitConverter.ToUInt16(RawData, 6);
			}
			set
			{
				FastBitConverter.GetBytes(RawData, 6, value);
			}
		}

		public ushort FragmentsTotal
		{
			get
			{
				return BitConverter.ToUInt16(RawData, 8);
			}
			set
			{
				FastBitConverter.GetBytes(RawData, 8, value);
			}
		}

		static NetPacket()
		{
			PropertiesCount = Enum.GetValues(typeof(PacketProperty)).Length;
			HeaderSizes = NetUtils.AllocatePinnedUninitializedArray<int>(PropertiesCount);
			for (int i = 0; i < HeaderSizes.Length; i++)
			{
				switch ((PacketProperty)(byte)i)
				{
				case PacketProperty.Channeled:
				case PacketProperty.Ack:
					HeaderSizes[i] = 4;
					break;
				case PacketProperty.Ping:
					HeaderSizes[i] = 3;
					break;
				case PacketProperty.ConnectRequest:
					HeaderSizes[i] = 18;
					break;
				case PacketProperty.ConnectAccept:
					HeaderSizes[i] = 15;
					break;
				case PacketProperty.Disconnect:
					HeaderSizes[i] = 9;
					break;
				case PacketProperty.Pong:
					HeaderSizes[i] = 11;
					break;
				default:
					HeaderSizes[i] = 1;
					break;
				}
			}
		}

		public void MarkFragmented()
		{
			RawData[0] |= 128;
		}

		public NetPacket(int size)
		{
			RawData = new byte[size];
			Size = size;
		}

		public NetPacket(PacketProperty property, int size)
		{
			size += GetHeaderSize(property);
			RawData = new byte[size];
			Property = property;
			Size = size;
		}

		public static int GetHeaderSize(PacketProperty property)
		{
			return HeaderSizes[(uint)property];
		}

		public int GetHeaderSize()
		{
			return HeaderSizes[RawData[0] & 0x1F];
		}

		public bool Verify()
		{
			byte b = (byte)(RawData[0] & 0x1Fu);
			if (b >= PropertiesCount)
			{
				return false;
			}
			int num = HeaderSizes[b];
			bool flag = (RawData[0] & 0x80) != 0;
			if (Size >= num)
			{
				if (flag)
				{
					return Size >= num + 6;
				}
				return true;
			}
			return false;
		}

		public static implicit operator Span<byte>(NetPacket p)
		{
			return new Span<byte>(p.RawData, 0, p.Size);
		}
	}
	[Flags]
	public enum ConnectionState : byte
	{
		Outgoing = 2,
		Connected = 4,
		ShutdownRequested = 8,
		Disconnected = 0x10,
		EndPointChange = 0x20,
		Any = 0x2E
	}
	internal enum ConnectRequestResult
	{
		None,
		P2PLose,
		Reconnection,
		NewConnection
	}
	internal enum DisconnectResult
	{
		None,
		Reject,
		Disconnect
	}
	internal enum ShutdownResult
	{
		None,
		Success,
		WasConnected
	}
	public class NetPeer : IPEndPoint
	{
		private class IncomingFragments
		{
			public NetPacket[] Fragments;

			public int ReceivedCount;

			public int TotalSize;

			public byte ChannelId;
		}

		private int _rtt;

		private int _avgRtt;

		private int _rttCount;

		private double _resendDelay = 27.0;

		private float _pingSendTimer;

		private float _rttResetTimer;

		private readonly Stopwatch _pingTimer = new Stopwatch();

		private volatile float _timeSinceLastPacket;

		private long _remoteDelta;

		private readonly object _shutdownLock = new object();

		internal volatile NetPeer NextPeer;

		internal NetPeer PrevPeer;

		private NetPacket[] _unreliableSecondQueue;

		private NetPacket[] _unreliableChannel;

		private int _unreliablePendingCount;

		private readonly object _unreliableChannelLock = new object();

		private readonly ConcurrentQueue<BaseChannel> _channelSendQueue;

		private readonly BaseChannel[] _channels;

		private int _mtu;

		private int _mtuIdx;

		private bool _finishMtu;

		private float _mtuCheckTimer;

		private int _mtuCheckAttempts;

		private const int MtuCheckDelay = 1000;

		private const int MaxMtuCheckAttempts = 4;

		private readonly object _mtuMutex = new object();

		private int _fragmentId;

		private readonly Dictionary<ushort, IncomingFragments> _holdedFragments;

		private readonly Dictionary<ushort, ushort> _deliveredFragments;

		private readonly NetPacket _mergeData;

		private int _mergePos;

		private int _mergeCount;

		private int _connectAttempts;

		private float _connectTimer;

		private long _connectTime;

		private byte _connectNum;

		private ConnectionState _connectionState;

		private NetPacket _shutdownPacket;

		private const int ShutdownDelay = 300;

		private float _shutdownTimer;

		private readonly NetPacket _pingPacket;

		private readonly NetPacket _pongPacket;

		private readonly NetPacket _connectRequestPacket;

		private readonly NetPacket _connectAcceptPacket;

		public readonly NetManager NetManager;

		public readonly int Id;

		public object Tag;

		public readonly NetStatistics Statistics;

		private SocketAddress _cachedSocketAddr;

		private int _cachedHashCode;

		internal byte[] NativeAddress;

		internal byte ConnectionNum
		{
			get
			{
				return _connectNum;
			}
			private set
			{
				_connectNum = value;
				_mergeData.ConnectionNumber = value;
				_pingPacket.ConnectionNumber = value;
				_pongPacket.ConnectionNumber = value;
			}
		}

		public ConnectionState ConnectionState => _connectionState;

		internal long ConnectTime => _connectTime;

		public int RemoteId { get; private set; }

		public int Ping => _avgRtt / 2;

		public int RoundTripTime => _avgRtt;

		public int Mtu => _mtu;

		public long RemoteTimeDelta => _remoteDelta;

		public DateTime RemoteUtcTime => new DateTime(DateTime.UtcNow.Ticks + _remoteDelta);

		public float TimeSinceLastPacket => _timeSinceLastPacket;

		internal double ResendDelay => _resendDelay;

		public override SocketAddress Serialize()
		{
			return _cachedSocketAddr;
		}

		public override int GetHashCode()
		{
			return _cachedHashCode;
		}

		internal NetPeer(NetManager netManager, IPEndPoint remoteEndPoint, int id)
			: base(remoteEndPoint.Address, remoteEndPoint.Port)
		{
			Id = id;
			Statistics = new NetStatistics();
			NetManager = netManager;
			_cachedSocketAddr = base.Serialize();
			if (NetManager.UseNativeSockets)
			{
				NativeAddress = new byte[_cachedSocketAddr.Size];
				for (int i = 0; i < _cachedSocketAddr.Size; i++)
				{
					NativeAddress[i] = _cachedSocketAddr[i];
				}
			}
			_cachedHashCode = base.GetHashCode();
			ResetMtu();
			_connectionState = ConnectionState.Connected;
			_mergeData = new NetPacket(PacketProperty.Merged, NetConstants.MaxPacketSize);
			_pongPacket = new NetPacket(PacketProperty.Pong, 0);
			_pingPacket = new NetPacket(PacketProperty.Ping, 0)
			{
				Sequence = 1
			};
			_unreliableSecondQueue = new NetPacket[8];
			_unreliableChannel = new NetPacket[8];
			_holdedFragments = new Dictionary<ushort, IncomingFragments>();
			_deliveredFragments = new Dictionary<ushort, ushort>();
			_channels = new BaseChannel[netManager.ChannelsCount * 4];
			_channelSendQueue = new ConcurrentQueue<BaseChannel>();
		}

		internal void InitiateEndPointChange()
		{
			ResetMtu();
			_connectionState = ConnectionState.EndPointChange;
		}

		internal void FinishEndPointChange(IPEndPoint newEndPoint)
		{
			if (_connectionState != ConnectionState.EndPointChange)
			{
				return;
			}
			_connectionState = ConnectionState.Connected;
			base.Address = newEndPoint.Address;
			base.Port = newEndPoint.Port;
			if (NetManager.UseNativeSockets)
			{
				NativeAddress = new byte[_cachedSocketAddr.Size];
				for (int i = 0; i < _cachedSocketAddr.Size; i++)
				{
					NativeAddress[i] = _cachedSocketAddr[i];
				}
			}
			_cachedSocketAddr = base.Serialize();
			_cachedHashCode = base.GetHashCode();
		}

		internal void ResetMtu()
		{
			_finishMtu = !NetManager.MtuDiscovery;
			if (NetManager.MtuOverride > 0)
			{
				OverrideMtu(NetManager.MtuOverride);
			}
			else
			{
				SetMtu(0);
			}
		}

		private void SetMtu(int mtuIdx)
		{
			_mtuIdx = mtuIdx;
			_mtu = NetConstants.PossibleMtu[mtuIdx] - NetManager.ExtraPacketSizeForLayer;
		}

		private void OverrideMtu(int mtuValue)
		{
			_mtu = mtuValue;
			_finishMtu = true;
		}

		public int GetPacketsCountInReliableQueue(byte channelNumber, bool ordered)
		{
			int num = channelNumber * 4 + (ordered ? 2 : 0);
			BaseChannel baseChannel = _channels[num];
			if (baseChannel == null)
			{
				return 0;
			}
			return ((ReliableChannel)baseChannel).PacketsInQueue;
		}

		public PooledPacket CreatePacketFromPool(DeliveryMethod deliveryMethod, byte channelNumber)
		{
			int mtu = _mtu;
			NetPacket netPacket = NetManager.PoolGetPacket(mtu);
			if (deliveryMethod == DeliveryMethod.Unreliable)
			{
				netPacket.Property = PacketProperty.Unreliable;
				return new PooledPacket(netPacket, mtu, 0);
			}
			netPacket.Property = PacketProperty.Channeled;
			return new PooledPacket(netPacket, mtu, (byte)((uint)(channelNumber * 4) + (uint)deliveryMethod));
		}

		public void SendPooledPacket(PooledPacket packet, int userDataSize)
		{
			if (_connectionState == ConnectionState.Connected)
			{
				packet._packet.Size = packet.UserDataOffset + userDataSize;
				if (packet._packet.Property == PacketProperty.Channeled)
				{
					CreateChannel(packet._channelNumber).AddToQueue(packet._packet);
				}
				else
				{
					EnqueueUnreliable(packet._packet);
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void EnqueueUnreliable(NetPacket packet)
		{
			lock (_unreliableChannelLock)
			{
				if (_unreliablePendingCount == _unreliableChannel.Length)
				{
					Array.Resize(ref _unreliableChannel, _unreliablePendingCount * 2);
				}
				_unreliableChannel[_unreliablePendingCount++] = packet;
			}
		}

		private BaseChannel CreateChannel(byte idx)
		{
			BaseChannel baseChannel = _channels[idx];
			if (baseChannel != null)
			{
				return baseChannel;
			}
			switch ((DeliveryMethod)(byte)(idx % 4))
			{
			case DeliveryMethod.ReliableUnordered:
				baseChannel = new ReliableChannel(this, ordered: false, idx);
				break;
			case DeliveryMethod.Sequenced:
				baseChannel = new SequencedChannel(this, reliable: false, idx);
				break;
			case DeliveryMethod.ReliableOrdered:
				baseChannel = new ReliableChannel(this, ordered: true, idx);
				break;
			case DeliveryMethod.ReliableSequenced:
				baseChannel = new SequencedChannel(this, reliable: true, idx);
				break;
			}
			BaseChannel baseChannel2 = Interlocked.CompareExchange(ref _channels[idx], baseChannel, null);
			if (baseChannel2 != null)
			{
				return baseChannel2;
			}
			return baseChannel;
		}

		internal NetPeer(NetManager netManager, IPEndPoint remoteEndPoint, int id, byte connectNum, NetDataWriter connectData)
			: this(netManager, remoteEndPoint, id)
		{
			_connectTime = DateTime.UtcNow.Ticks;
			_connectionState = ConnectionState.Outgoing;
			ConnectionNum = connectNum;
			_connectRequestPacket = NetConnectRequestPacket.Make(connectData, remoteEndPoint.Serialize(), _connectTime, id);
			_connectRequestPacket.ConnectionNumber = connectNum;
			NetManager.SendRaw(_connectRequestPacket, this);
		}

		internal NetPeer(NetManager netManager, ConnectionRequest request, int id)
			: this(netManager, request.RemoteEndPoint, id)
		{
			_connectTime = request.InternalPacket.ConnectionTime;
			ConnectionNum = request.InternalPacket.ConnectionNumber;
			RemoteId = request.InternalPacket.PeerId;
			_connectAcceptPacket = NetConnectAcceptPacket.Make(_connectTime, ConnectionNum, id);
			_connectionState = ConnectionState.Connected;
			NetManager.SendRaw(_connectAcceptPacket, this);
		}

		internal void Reject(NetConnectRequestPacket requestData, byte[] data, int start, int length)
		{
			_connectTime = requestData.ConnectionTime;
			_connectNum = requestData.ConnectionNumber;
			Shutdown(data, start, length, force: false);
		}

		internal bool ProcessConnectAccept(NetConnectAcceptPacket packet)
		{
			if (_connectionState != ConnectionState.Outgoing)
			{
				return false;
			}
			if (packet.ConnectionTime != _connectTime)
			{
				return false;
			}
			ConnectionNum = packet.ConnectionNumber;
			RemoteId = packet.PeerId;
			Interlocked.Exchange(ref _timeSinceLastPacket, 0f);
			_connectionState = ConnectionState.Connected;
			return true;
		}

		public int GetMaxSinglePacketSize(DeliveryMethod options)
		{
			return _mtu - NetPacket.GetHeaderSize((options != DeliveryMethod.Unreliable) ? PacketProperty.Channeled : PacketProperty.Unreliable);
		}

		public void SendWithDeliveryEvent(byte[] data, byte channelNumber, DeliveryMethod deliveryMethod, object userData)
		{
			if (deliveryMethod != DeliveryMethod.ReliableOrdered && deliveryMethod != 0)
			{
				throw new ArgumentException("Delivery event will work only for ReliableOrdered/Unordered packets");
			}
			SendInternal(data, 0, data.Length, channelNumber, deliveryMethod, userData);
		}

		public void SendWithDeliveryEvent(byte[] data, int start, int length, byte channelNumber, DeliveryMethod deliveryMethod, object userData)
		{
			if (deliveryMethod != DeliveryMethod.ReliableOrdered && deliveryMethod != 0)
			{
				throw new ArgumentException("Delivery event will work only for ReliableOrdered/Unordered packets");
			}
			SendInternal(data, start, length, channelNumber, deliveryMethod, userData);
		}

		public void SendWithDeliveryEvent(NetDataWriter dataWriter, byte channelNumber, DeliveryMethod deliveryMethod, object userData)
		{
			if (deliveryMethod != DeliveryMethod.ReliableOrdered && deliveryMethod != 0)
			{
				throw new ArgumentException("Delivery event will work only for ReliableOrdered/Unordered packets");
			}
			SendInternal(dataWriter.Data, 0, dataWriter.Length, channelNumber, deliveryMethod, userData);
		}

		public void Send(byte[] data, DeliveryMethod deliveryMethod)
		{
			SendInternal(data, 0, data.Length, 0, deliveryMethod, null);
		}

		public void Send(NetDataWriter dataWriter, DeliveryMethod deliveryMethod)
		{
			SendInternal(dataWriter.Data, 0, dataWriter.Length, 0, deliveryMethod, null);
		}

		public void Send(byte[] data, int start, int length, DeliveryMethod options)
		{
			SendInternal(data, start, length, 0, options, null);
		}

		public void Send(byte[] data, byte channelNumber, DeliveryMethod deliveryMethod)
		{
			SendInternal(data, 0, data.Length, channelNumber, deliveryMethod, null);
		}

		public void Send(NetDataWriter dataWriter, byte channelNumber, DeliveryMethod deliveryMethod)
		{
			SendInternal(dataWriter.Data, 0, dataWriter.Length, channelNumber, deliveryMethod, null);
		}

		public void Send(byte[] data, int start, int length, byte channelNumber, DeliveryMethod deliveryMethod)
		{
			SendInternal(data, start, length, channelNumber, deliveryMethod, null);
		}

		private void SendInternal(byte[] data, int start, int length, byte channelNumber, DeliveryMethod deliveryMethod, object userData)
		{
			if (_connectionState != ConnectionState.Connected || channelNumber >= _channels.Length)
			{
				return;
			}
			BaseChannel baseChannel = null;
			PacketProperty property;
			if (deliveryMethod == DeliveryMethod.Unreliable)
			{
				property = PacketProperty.Unreliable;
			}
			else
			{
				property = PacketProperty.Channeled;
				baseChannel = CreateChannel((byte)((uint)(channelNumber * 4) + (uint)deliveryMethod));
			}
			int headerSize = NetPacket.GetHeaderSize(property);
			int mtu = _mtu;
			if (length + headerSize > mtu)
			{
				if (deliveryMethod != DeliveryMethod.ReliableOrdered && deliveryMethod != 0)
				{
					throw new TooBigPacketException("Unreliable or ReliableSequenced packet size exceeded maximum of " + (mtu - headerSize) + " bytes, Check allowed size by GetMaxSinglePacketSize()");
				}
				int num = mtu - headerSize - 6;
				int num2 = length / num + ((length % num != 0) ? 1 : 0);
				if (num2 > 65535)
				{
					throw new TooBigPacketException("Data was split in " + num2 + " fragments, which exceeds " + ushort.MaxValue);
				}
				ushort fragmentId = (ushort)Interlocked.Increment(ref _fragmentId);
				for (ushort num3 = 0; num3 < num2; num3++)
				{
					int num4 = ((length > num) ? num : length);
					NetPacket netPacket = NetManager.PoolGetPacket(headerSize + num4 + 6);
					netPacket.Property = property;
					netPacket.UserData = userData;
					netPacket.FragmentId = fragmentId;
					netPacket.FragmentPart = num3;
					netPacket.FragmentsTotal = (ushort)num2;
					netPacket.MarkFragmented();
					Buffer.BlockCopy(data, start + num3 * num, netPacket.RawData, 10, num4);
					baseChannel.AddToQueue(netPacket);
					length -= num4;
				}
			}
			else
			{
				NetPacket netPacket2 = NetManager.PoolGetPacket(headerSize + length);
				netPacket2.Property = property;
				Buffer.BlockCopy(data, start, netPacket2.RawData, headerSize, length);
				netPacket2.UserData = userData;
				if (baseChannel == null)
				{
					EnqueueUnreliable(netPacket2);
				}
				else
				{
					baseChannel.AddToQueue(netPacket2);
				}
			}
		}

		public void SendWithDeliveryEvent(ReadOnlySpan<byte> data, byte channelNumber, DeliveryMethod deliveryMethod, object userData)
		{
			if (deliveryMethod != DeliveryMethod.ReliableOrdered && deliveryMethod != 0)
			{
				throw new ArgumentException("Delivery event will work only for ReliableOrdered/Unordered packets");
			}
			SendInternal(data, channelNumber, deliveryMethod, userData);
		}

		public void Send(ReadOnlySpan<byte> data, DeliveryMethod deliveryMethod)
		{
			SendInternal(data, 0, deliveryMethod, null);
		}

		public void Send(ReadOnlySpan<byte> data, byte channelNumber, DeliveryMethod deliveryMethod)
		{
			SendInternal(data, channelNumber, deliveryMethod, null);
		}

		private void SendInternal(ReadOnlySpan<byte> data, byte channelNumber, DeliveryMethod deliveryMethod, object userData)
		{
			if (_connectionState != ConnectionState.Connected || channelNumber >= _channels.Length)
			{
				return;
			}
			BaseChannel baseChannel = null;
			PacketProperty property;
			if (deliveryMethod == DeliveryMethod.Unreliable)
			{
				property = PacketProperty.Unreliable;
			}
			else
			{
				property = PacketProperty.Channeled;
				baseChannel = CreateChannel((byte)((uint)(channelNumber * 4) + (uint)deliveryMethod));
			}
			int headerSize = NetPacket.GetHeaderSize(property);
			int mtu = _mtu;
			int num = data.Length;
			if (num + headerSize > mtu)
			{
				if (deliveryMethod != DeliveryMethod.ReliableOrdered && deliveryMethod != 0)
				{
					throw new TooBigPacketException("Unreliable or ReliableSequenced packet size exceeded maximum of " + (mtu - headerSize) + " bytes, Check allowed size by GetMaxSinglePacketSize()");
				}
				int num2 = mtu - headerSize - 6;
				int num3 = num / num2 + ((num % num2 != 0) ? 1 : 0);
				if (num3 > 65535)
				{
					throw new TooBigPacketException("Data was split in " + num3 + " fragments, which exceeds " + ushort.MaxValue);
				}
				ushort fragmentId = (ushort)Interlocked.Increment(ref _fragmentId);
				for (ushort num4 = 0; num4 < num3; num4++)
				{
					int num5 = ((num > num2) ? num2 : num);
					NetPacket netPacket = NetManager.PoolGetPacket(headerSize + num5 + 6);
					netPacket.Property = property;
					netPacket.UserData = userData;
					netPacket.FragmentId = fragmentId;
					netPacket.FragmentPart = num4;
					netPacket.FragmentsTotal = (ushort)num3;
					netPacket.MarkFragmented();
					data.Slice(num4 * num2, num5).CopyTo(new Span<byte>(netPacket.RawData, 10, num5));
					baseChannel.AddToQueue(netPacket);
					num -= num5;
				}
			}
			else
			{
				NetPacket netPacket2 = NetManager.PoolGetPacket(headerSize + num);
				netPacket2.Property = property;
				data.CopyTo(new Span<byte>(netPacket2.RawData, headerSize, num));
				netPacket2.UserData = userData;
				if (baseChannel == null)
				{
					EnqueueUnreliable(netPacket2);
				}
				else
				{
					baseChannel.AddToQueue(netPacket2);
				}
			}
		}

		public void Disconnect(byte[] data)
		{
			NetManager.DisconnectPeer(this, data);
		}

		public void Disconnect(NetDataWriter writer)
		{
			NetManager.DisconnectPeer(this, writer);
		}

		public void Disconnect(byte[] data, int start, int count)
		{
			NetManager.DisconnectPeer(this, data, start, count);
		}

		public void Disconnect()
		{
			NetManager.DisconnectPeer(this);
		}

		internal DisconnectResult ProcessDisconnect(NetPacket packet)
		{
			if ((_connectionState == ConnectionState.Connected || _connectionState == ConnectionState.Outgoing) && packet.Size >= 9 && BitConverter.ToInt64(packet.RawData, 1) == _connectTime && packet.ConnectionNumber == _connectNum)
			{
				if (_connectionState != ConnectionState.Connected)
				{
					return DisconnectResult.Reject;
				}
				return DisconnectResult.Disconnect;
			}
			return DisconnectResult.None;
		}

		internal void AddToReliableChannelSendQueue(BaseChannel channel)
		{
			_channelSendQueue.Enqueue(channel);
		}

		internal ShutdownResult Shutdown(byte[] data, int start, int length, bool force)
		{
			lock (_shutdownLock)
			{
				if (_connectionState == ConnectionState.Disconnected || _connectionState == ConnectionState.ShutdownRequested)
				{
					return ShutdownResult.None;
				}
				ShutdownResult result = ((_connectionState != ConnectionState.Connected) ? ShutdownResult.Success : ShutdownResult.WasConnected);
				if (force)
				{
					_connectionState = ConnectionState.Disconnected;
					return result;
				}
				Interlocked.Exchange(ref _timeSinceLastPacket, 0f);
				_shutdownPacket = new NetPacket(PacketProperty.Disconnect, length)
				{
					ConnectionNumber = _connectNum
				};
				FastBitConverter.GetBytes(_shutdownPacket.RawData, 1, _connectTime);
				if (_shutdownPacket.Size >= _mtu)
				{
					NetDebug.WriteError("[Peer] Disconnect additional data size more than MTU - 8!");
				}
				else if (data != null && length > 0)
				{
					Buffer.BlockCopy(data, start, _shutdownPacket.RawData, 9, length);
				}
				_connectionState = ConnectionState.ShutdownRequested;
				NetManager.SendRaw(_shutdownPacket, this);
				return result;
			}
		}

		private void UpdateRoundTripTime(int roundTripTime)
		{
			_rtt += roundTripTime;
			_rttCount++;
			_avgRtt = _rtt / _rttCount;
			_resendDelay = 25.0 + (double)_avgRtt * 2.1;
		}

		internal void AddReliablePacket(DeliveryMethod method, NetPacket p)
		{
			if (p.IsFragmented)
			{
				ushort fragmentId = p.FragmentId;
				byte channelId = p.ChannelId;
				if (!_holdedFragments.TryGetValue(fragmentId, out var value))
				{
					value = new IncomingFragments
					{
						Fragments = new NetPacket[p.FragmentsTotal],
						ChannelId = p.ChannelId
					};
					_holdedFragments.Add(fragmentId, value);
				}
				NetPacket[] fragments = value.Fragments;
				if (p.FragmentPart >= fragments.Length || fragments[p.FragmentPart] != null || p.ChannelId != value.ChannelId)
				{
					NetManager.PoolRecycle(p);
					NetDebug.WriteError("Invalid fragment packet");
					return;
				}
				fragments[p.FragmentPart] = p;
				value.ReceivedCount++;
				value.TotalSize += p.Size - 10;
				if (value.ReceivedCount != fragments.Length)
				{
					return;
				}
				NetPacket netPacket = NetManager.PoolGetPacket(value.TotalSize);
				int num = 0;
				for (int i = 0; i < value.ReceivedCount; i++)
				{
					NetPacket netPacket2 = fragments[i];
					int num2 = netPacket2.Size - 10;
					if (num + num2 > netPacket.RawData.Length)
					{
						_holdedFragments.Remove(fragmentId);
						NetDebug.WriteError($"Fragment error pos: {num + num2} >= resultPacketSize: {netPacket.RawData.Length} , totalSize: {value.TotalSize}");
						return;
					}
					if (netPacket2.Size > netPacket2.RawData.Length)
					{
						_holdedFragments.Remove(fragmentId);
						NetDebug.WriteError($"Fragment error size: {netPacket2.Size} > fragment.RawData.Length: {netPacket2.RawData.Length}");
						return;
					}
					Buffer.BlockCopy(netPacket2.RawData, 10, netPacket.RawData, num, num2);
					num += num2;
					NetManager.PoolRecycle(netPacket2);
					fragments[i] = null;
				}
				_holdedFragments.Remove(fragmentId);
				NetManager.CreateReceiveEvent(netPacket, method, (byte)(channelId / 4), 0, this);
			}
			else
			{
				NetManager.CreateReceiveEvent(p, method, (byte)(p.ChannelId / 4), 4, this);
			}
		}

		private void ProcessMtuPacket(NetPacket packet)
		{
			if (packet.Size < NetConstants.PossibleMtu[0])
			{
				return;
			}
			int num = BitConverter.ToInt32(packet.RawData, 1);
			int num2 = BitConverter.ToInt32(packet.RawData, packet.Size - 4);
			if (num != packet.Size || num != num2 || num > NetConstants.MaxPacketSize)
			{
				NetDebug.WriteError($"[MTU] Broken packet. RMTU {num}, EMTU {num2}, PSIZE {packet.Size}");
			}
			else if (packet.Property == PacketProperty.MtuCheck)
			{
				_mtuCheckAttempts = 0;
				packet.Property = PacketProperty.MtuOk;
				NetManager.SendRawAndRecycle(packet, this);
			}
			else if (num > _mtu && !_finishMtu && num == NetConstants.PossibleMtu[_mtuIdx + 1] - NetManager.ExtraPacketSizeForLayer)
			{
				lock (_mtuMutex)
				{
					SetMtu(_mtuIdx + 1);
				}
				if (_mtuIdx == NetConstants.PossibleMtu.Length - 1)
				{
					_finishMtu = true;
				}
				NetManager.PoolRecycle(packet);
			}
		}

		private void UpdateMtuLogic(float deltaTime)
		{
			if (_finishMtu)
			{
				return;
			}
			_mtuCheckTimer += deltaTime;
			if (_mtuCheckTimer < 1000f)
			{
				return;
			}
			_mtuCheckTimer = 0f;
			_mtuCheckAttempts++;
			if (_mtuCheckAttempts >= 4)
			{
				_finishMtu = true;
				return;
			}
			lock (_mtuMutex)
			{
				if (_mtuIdx < NetConstants.PossibleMtu.Length - 1)
				{
					int num = NetConstants.PossibleMtu[_mtuIdx + 1] - NetManager.ExtraPacketSizeForLayer;
					NetPacket netPacket = NetManager.PoolGetPacket(num);
					netPacket.Property = PacketProperty.MtuCheck;
					FastBitConverter.GetBytes(netPacket.RawData, 1, num);
					FastBitConverter.GetBytes(netPacket.RawData, netPacket.Size - 4, num);
					if (NetManager.SendRawAndRecycle(netPacket, this) <= 0)
					{
						_finishMtu = true;
					}
				}
			}
		}

		internal ConnectRequestResult ProcessConnectRequest(NetConnectRequestPacket connRequest)
		{
			switch (_connectionState)
			{
			case ConnectionState.Outgoing:
			{
				if (connRequest.ConnectionTime < _connectTime)
				{
					return ConnectRequestResult.P2PLose;
				}
				if (connRequest.ConnectionTime != _connectTime)
				{
					break;
				}
				byte[] targetAddress = connRequest.TargetAddress;
				for (int num = _cachedSocketAddr.Size - 1; num >= 0; num--)
				{
					byte b = _cachedSocketAddr[num];
					if (b != targetAddress[num] && b < targetAddress[num])
					{
						return ConnectRequestResult.P2PLose;
					}
				}
				break;
			}
			case ConnectionState.Connected:
				if (connRequest.ConnectionTime == _connectTime)
				{
					NetManager.SendRaw(_connectAcceptPacket, this);
				}
				else if (connRequest.ConnectionTime > _connectTime)
				{
					return ConnectRequestResult.Reconnection;
				}
				break;
			case ConnectionState.ShutdownRequested:
			case ConnectionState.Disconnected:
				if (connRequest.ConnectionTime >= _connectTime)
				{
					return ConnectRequestResult.NewConnection;
				}
				break;
			}
			return ConnectRequestResult.None;
		}

		internal void ProcessPacket(NetPacket packet)
		{
			if (_connectionState == ConnectionState.Outgoing || _connectionState == ConnectionState.Disconnected)
			{
				NetManager.PoolRecycle(packet);
				return;
			}
			if (packet.Property == PacketProperty.ShutdownOk)
			{
				if (_connectionState == ConnectionState.ShutdownRequested)
				{
					_connectionState = ConnectionState.Disconnected;
				}
				NetManager.PoolRecycle(packet);
				return;
			}
			if (packet.ConnectionNumber != _connectNum)
			{
				NetManager.PoolRecycle(packet);
				return;
			}
			Interlocked.Exchange(ref _timeSinceLastPacket, 0f);
			switch (packet.Property)
			{
			case PacketProperty.Merged:
			{
				int num2 = 1;
				while (num2 < packet.Size)
				{
					ushort num3 = BitConverter.ToUInt16(packet.RawData, num2);
					if (num3 == 0)
					{
						break;
					}
					num2 += 2;
					if (packet.RawData.Length - num2 < num3)
					{
						break;
					}
					NetPacket netPacket = NetManager.PoolGetPacket(num3);
					Buffer.BlockCopy(packet.RawData, num2, netPacket.RawData, 0, num3);
					netPacket.Size = num3;
					if (!netPacket.Verify())
					{
						break;
					}
					num2 += num3;
					ProcessPacket(netPacket);
				}
				NetManager.PoolRecycle(packet);
				break;
			}
			case PacketProperty.Ping:
				if (NetUtils.RelativeSequenceNumber(packet.Sequence, _pongPacket.Sequence) > 0)
				{
					FastBitConverter.GetBytes(_pongPacket.RawData, 3, DateTime.UtcNow.Ticks);
					_pongPacket.Sequence = packet.Sequence;
					NetManager.SendRaw(_pongPacket, this);
				}
				NetManager.PoolRecycle(packet);
				break;
			case PacketProperty.Pong:
				if (packet.Sequence == _pingPacket.Sequence)
				{
					_pingTimer.Stop();
					int num = (int)_pingTimer.ElapsedMilliseconds;
					_remoteDelta = BitConverter.ToInt64(packet.RawData, 3) + (long)num * 10000L / 2 - DateTime.UtcNow.Ticks;
					UpdateRoundTripTime(num);
					NetManager.ConnectionLatencyUpdated(this, num / 2);
				}
				NetManager.PoolRecycle(packet);
				break;
			case PacketProperty.Channeled:
			case PacketProperty.Ack:
			{
				if (packet.ChannelId >= _channels.Length)
				{
					NetManager.PoolRecycle(packet);
					break;
				}
				BaseChannel baseChannel = _channels[packet.ChannelId] ?? ((packet.Property == PacketProperty.Ack) ? null : CreateChannel(packet.ChannelId));
				if (baseChannel != null && !baseChannel.ProcessPacket(packet))
				{
					NetManager.PoolRecycle(packet);
				}
				break;
			}
			case PacketProperty.Unreliable:
				NetManager.CreateReceiveEvent(packet, DeliveryMethod.Unreliable, 0, 1, this);
				break;
			case PacketProperty.MtuCheck:
			case PacketProperty.MtuOk:
				ProcessMtuPacket(packet);
				break;
			default:
				NetDebug.WriteError("Error! Unexpected packet type: " + packet.Property);
				break;
			}
		}

		private void SendMerged()
		{
			if (_mergeCount != 0)
			{
				int num = ((_mergeCount <= 1) ? NetManager.SendRaw(_mergeData.RawData, 3, _mergePos - 2, this) : NetManager.SendRaw(_mergeData.RawData, 0, 1 + _mergePos, this));
				if (NetManager.EnableStatistics)
				{
					Statistics.IncrementPacketsSent();
					Statistics.AddBytesSent(num);
				}
				_mergePos = 0;
				_mergeCount = 0;
			}
		}

		internal void SendUserData(NetPacket packet)
		{
			packet.ConnectionNumber = _connectNum;
			int num = 1 + packet.Size + 2;
			if (num + 20 >= _mtu)
			{
				int num2 = NetManager.SendRaw(packet, this);
				if (NetManager.EnableStatistics)
				{
					Statistics.IncrementPacketsSent();
					Statistics.AddBytesSent(num2);
				}
				return;
			}
			if (_mergePos + num > _mtu)
			{
				SendMerged();
			}
			FastBitConverter.GetBytes(_mergeData.RawData, _mergePos + 1, (ushort)packet.Size);
			Buffer.BlockCopy(packet.RawData, 0, _mergeData.RawData, _mergePos + 1 + 2, packet.Size);
			_mergePos += packet.Size + 2;
			_mergeCount++;
		}

		internal void Update(float deltaTime)
		{
			_timeSinceLastPacket += deltaTime;
			switch (_connectionState)
			{
			case ConnectionState.Connected:
				if (_timeSinceLastPacket > (float)NetManager.DisconnectTimeout)
				{
					NetManager.DisconnectPeerForce(this, DisconnectReason.Timeout, SocketError.Success, null);
					return;
				}
				break;
			case ConnectionState.ShutdownRequested:
				if (_timeSinceLastPacket > (float)NetManager.DisconnectTimeout)
				{
					_connectionState = ConnectionState.Disconnected;
					return;
				}
				_shutdownTimer += deltaTime;
				if (_shutdownTimer >= 300f)
				{
					_shutdownTimer = 0f;
					NetManager.SendRaw(_shutdownPacket, this);
				}
				return;
			case ConnectionState.Outgoing:
				_connectTimer += deltaTime;
				if (_connectTimer > (float)NetManager.ReconnectDelay)
				{
					_connectTimer = 0f;
					_connectAttempts++;
					if (_connectAttempts > NetManager.MaxConnectAttempts)
					{
						NetManager.DisconnectPeerForce(this, DisconnectReason.ConnectionFailed, SocketError.Success, null);
					}
					else
					{
						NetManager.SendRaw(_connectRequestPacket, this);
					}
				}
				return;
			case ConnectionState.Disconnected:
				return;
			}
			_pingSendTimer += deltaTime;
			if (_pingSendTimer >= (float)NetManager.PingInterval)
			{
				_pingSendTimer = 0f;
				_pingPacket.Sequence++;
				if (_pingTimer.IsRunning)
				{
					UpdateRoundTripTime((int)_pingTimer.ElapsedMilliseconds);
				}
				_pingTimer.Restart();
				NetManager.SendRaw(_pingPacket, this);
			}
			_rttResetTimer += deltaTime;
			if (_rttResetTimer >= (float)(NetManager.PingInterval * 3))
			{
				_rttResetTimer = 0f;
				_rtt = _avgRtt;
				_rttCount = 1;
			}
			UpdateMtuLogic(deltaTime);
			int count = _channelSendQueue.Count;
			BaseChannel result;
			while (count-- > 0 && _channelSendQueue.TryDequeue(out result))
			{
				if (result.SendAndCheckQueue())
				{
					_channelSendQueue.Enqueue(result);
				}
			}
			if (_unreliablePendingCount > 0)
			{
				int unreliablePendingCount;
				lock (_unreliableChannelLock)
				{
					NetPacket[] unreliableSecondQueue = _unreliableSecondQueue;
					NetPacket[] unreliableChannel = _unreliableChannel;
					_unreliableChannel = unreliableSecondQueue;
					_unreliableSecondQueue = unreliableChannel;
					unreliablePendingCount = _unreliablePendingCount;
					_unreliablePendingCount = 0;
				}
				for (int i = 0; i < unreliablePendingCount; i++)
				{
					NetPacket packet = _unreliableSecondQueue[i];
					SendUserData(packet);
					NetManager.PoolRecycle(packet);
				}
			}
			SendMerged();
		}

		internal void RecycleAndDeliver(NetPacket packet)
		{
			if (packet.UserData != null)
			{
				if (packet.IsFragmented)
				{
					_deliveredFragments.TryGetValue(packet.FragmentId, out var value);
					value++;
					if (value == packet.FragmentsTotal)
					{
						NetManager.MessageDelivered(this, packet.UserData);
						_deliveredFragments.Remove(packet.FragmentId);
					}
					else
					{
						_deliveredFragments[packet.FragmentId] = value;
					}
				}
				else
				{
					NetManager.MessageDelivered(this, packet.UserData);
				}
				packet.UserData = null;
			}
			NetManager.PoolRecycle(packet);
		}
	}
	public sealed class NetStatistics
	{
		private long _packetsSent;

		private long _packetsReceived;

		private long _bytesSent;

		private long _bytesReceived;

		private long _packetLoss;

		public long PacketsSent => Interlocked.Read(ref _packetsSent);

		public long PacketsReceived => Interlocked.Read(ref _packetsReceived);

		public long BytesSent => Interlocked.Read(ref _bytesSent);

		public long BytesReceived => Interlocked.Read(ref _bytesReceived);

		public long PacketLoss => Interlocked.Read(ref _packetLoss);

		public long PacketLossPercent
		{
			get
			{
				long packetsSent = PacketsSent;
				long packetLoss = PacketLoss;
				if (packetsSent != 0L)
				{
					return packetLoss * 100 / packetsSent;
				}
				return 0L;
			}
		}

		public void Reset()
		{
			Interlocked.Exchange(ref _packetsSent, 0L);
			Interlocked.Exchange(ref _packetsReceived, 0L);
			Interlocked.Exchange(ref _bytesSent, 0L);
			Interlocked.Exchange(ref _bytesReceived, 0L);
			Interlocked.Exchange(ref _packetLoss, 0L);
		}

		public void IncrementPacketsSent()
		{
			Interlocked.Increment(ref _packetsSent);
		}

		public void IncrementPacketsReceived()
		{
			Interlocked.Increment(ref _packetsReceived);
		}

		public void AddBytesSent(long bytesSent)
		{
			Interlocked.Add(ref _bytesSent, bytesSent);
		}

		public void AddBytesReceived(long bytesReceived)
		{
			Interlocked.Add(ref _bytesReceived, bytesReceived);
		}

		public void IncrementPacketLoss()
		{
			Interlocked.Increment(ref _packetLoss);
		}

		public void AddPacketLoss(long packetLoss)
		{
			Interlocked.Add(ref _packetLoss, packetLoss);
		}

		public override string ToString()
		{
			return $"BytesReceived: {BytesReceived}\nPacketsReceived: {PacketsReceived}\nBytesSent: {BytesSent}\nPacketsSent: {PacketsSent}\nPacketLoss: {PacketLoss}\nPacketLossPercent: {PacketLossPercent}\n";
		}
	}
	[Flags]
	public enum LocalAddrType
	{
		IPv4 = 1,
		IPv6 = 2,
		All = 3
	}
	public static class NetUtils
	{
		private static readonly NetworkSorter NetworkSorter = new NetworkSorter();

		private static readonly List<string> IpList = new List<string>();

		public static IPEndPoint MakeEndPoint(string hostStr, int port)
		{
			return new IPEndPoint(ResolveAddress(hostStr), port);
		}

		public static IPAddress ResolveAddress(string hostStr)
		{
			if (hostStr == "localhost")
			{
				return IPAddress.Loopback;
			}
			if (!IPAddress.TryParse(hostStr, out IPAddress address))
			{
				if (NetManager.IPv6Support)
				{
					address = ResolveAddress(hostStr, AddressFamily.InterNetworkV6);
				}
				if (address == null)
				{
					address = ResolveAddress(hostStr, AddressFamily.InterNetwork);
				}
			}
			if (address == null)
			{
				throw new ArgumentException("Invalid address: " + hostStr);
			}
			return address;
		}

		public static IPAddress ResolveAddress(string hostStr, AddressFamily addressFamily)
		{
			IPAddress[] addressList = Dns.GetHostEntry(hostStr).AddressList;
			foreach (IPAddress iPAddress in addressList)
			{
				if (iPAddress.AddressFamily == addressFamily)
				{
					return iPAddress;
				}
			}
			return null;
		}

		public static List<string> GetLocalIpList(LocalAddrType addrType)
		{
			List<string> list = new List<string>();
			GetLocalIpList(list, addrType);
			return list;
		}

		public static void GetLocalIpList(IList<string> targetList, LocalAddrType addrType)
		{
			bool flag = (addrType & LocalAddrType.IPv4) == LocalAddrType.IPv4;
			bool flag2 = (addrType & LocalAddrType.IPv6) == LocalAddrType.IPv6;
			try
			{
				NetworkInterface[] allNetworkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
				Array.Sort(allNetworkInterfaces, NetworkSorter);
				NetworkInterface[] array = allNetworkInterfaces;
				foreach (NetworkInterface networkInterface in array)
				{
					if (networkInterface.NetworkInterfaceType == NetworkInterfaceType.Loopback || networkInterface.OperationalStatus != OperationalStatus.Up)
					{
						continue;
					}
					IPInterfaceProperties iPProperties = networkInterface.GetIPProperties();
					if (iPProperties.GatewayAddresses.Count == 0)
					{
						continue;
					}
					foreach (UnicastIPAddressInformation unicastAddress in iPProperties.UnicastAddresses)
					{
						IPAddress address = unicastAddress.Address;
						if ((flag && address.AddressFamily == AddressFamily.InterNetwork) || (flag2 && address.AddressFamily == AddressFamily.InterNetworkV6))
						{
							targetList.Add(address.ToString());
						}
					}
				}
				if (targetList.Count == 0)
				{
					IPAddress[] addressList = Dns.GetHostEntry(Dns.GetHostName()).AddressList;
					foreach (IPAddress iPAddress in addressList)
					{
						if ((flag && iPAddress.AddressFamily == AddressFamily.InterNetwork) || (flag2 && iPAddress.AddressFamily == AddressFamily.InterNetworkV6))
						{
							targetList.Add(iPAddress.ToString());
						}
					}
				}
			}
			catch
			{
			}
			if (targetList.Count == 0)
			{
				if (flag)
				{
					targetList.Add("127.0.0.1");
				}
				if (flag2)
				{
					targetList.Add("::1");
				}
			}
		}

		public static string GetLocalIp(LocalAddrType addrType)
		{
			lock (IpList)
			{
				IpList.Clear();
				GetLocalIpList(IpList, addrType);
				return (IpList.Count == 0) ? string.Empty : IpList[0];
			}
		}

		internal static void PrintInterfaceInfos()
		{
			try
			{
				NetworkInterface[] allNetworkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
				for (int i = 0; i < allNetworkInterfaces.Length; i++)
				{
					foreach (UnicastIPAddressInformation unicastAddress in allNetworkInterfaces[i].GetIPProperties().UnicastAddresses)
					{
						if (unicastAddress.Address.AddressFamily != AddressFamily.InterNetwork)
						{
							_ = unicastAddress.Address.AddressFamily;
							_ = 23;
						}
					}
				}
			}
			catch (Exception)
			{
			}
		}

		internal static int RelativeSequenceNumber(int number, int expected)
		{
			return (number - expected + 32768 + 16384) % 32768 - 16384;
		}

		internal static T[] AllocatePinnedUninitializedArray<T>(int count)
		{
			return GC.AllocateUninitializedArray<T>(count, pinned: true);
		}
	}
	internal class NetworkSorter : IComparer<NetworkInterface>
	{
		public int Compare(NetworkInterface a, NetworkInterface b)
		{
			bool num = a.NetworkInterfaceType == NetworkInterfaceType.Wman || a.NetworkInterfaceType == NetworkInterfaceType.Wwanpp || a.NetworkInterfaceType == NetworkInterfaceType.Wwanpp2;
			bool flag = b.NetworkInterfaceType == NetworkInterfaceType.Wman || b.NetworkInterfaceType == NetworkInterfaceType.Wwanpp || b.NetworkInterfaceType == NetworkInterfaceType.Wwanpp2;
			bool flag2 = a.NetworkInterfaceType == NetworkInterfaceType.Wireless80211;
			bool flag3 = b.NetworkInterfaceType == NetworkInterfaceType.Wireless80211;
			bool flag4 = a.NetworkInterfaceType == NetworkInterfaceType.Ethernet || a.NetworkInterfaceType == NetworkInterfaceType.Ethernet3Megabit || a.NetworkInterfaceType == NetworkInterfaceType.GigabitEthernet || a.NetworkInterfaceType == NetworkInterfaceType.FastEthernetFx || a.NetworkInterfaceType == NetworkInterfaceType.FastEthernetT;
			bool flag5 = b.NetworkInterfaceType == NetworkInterfaceType.Ethernet || b.NetworkInterfaceType == NetworkInterfaceType.Ethernet3Megabit || b.NetworkInterfaceType == NetworkInterfaceType.GigabitEthernet || b.NetworkInterfaceType == NetworkInterfaceType.FastEthernetFx || b.NetworkInterfaceType == NetworkInterfaceType.FastEthernetT;
			bool flag6 = !num && !flag2 && !flag4;
			bool flag7 = !flag && !flag3 && !flag5;
			int num2 = (flag4 ? 3 : (flag2 ? 2 : (flag6 ? 1 : 0)));
			int num3 = (flag5 ? 3 : (flag3 ? 2 : (flag7 ? 1 : 0)));
			if (num2 <= num3)
			{
				return (num2 < num3) ? 1 : 0;
			}
			return -1;
		}
	}
	public readonly ref struct PooledPacket
	{
		internal readonly NetPacket _packet;

		internal readonly byte _channelNumber;

		public readonly int MaxUserDataSize;

		public readonly int UserDataOffset;

		public byte[] Data => _packet.RawData;

		internal PooledPacket(NetPacket packet, int maxDataSize, byte channelNumber)
		{
			_packet = packet;
			UserDataOffset = _packet.GetHeaderSize();
			_packet.Size = UserDataOffset;
			MaxUserDataSize = maxDataSize - UserDataOffset;
			_channelNumber = channelNumber;
		}
	}
	internal sealed class ReliableChannel : BaseChannel
	{
		private struct PendingPacket
		{
			private NetPacket _packet;

			private long _timeStamp;

			private bool _isSent;

			public override string ToString()
			{
				if (_packet != null)
				{
					return _packet.Sequence.ToString();
				}
				return "Empty";
			}

			public void Init(NetPacket packet)
			{
				_packet = packet;
				_isSent = false;
			}

			public bool TrySend(long currentTime, NetPeer peer)
			{
				if (_packet == null)
				{
					return false;
				}
				if (_isSent)
				{
					double num = peer.ResendDelay * 10000.0;
					if ((double)(currentTime - _timeStamp) < num)
					{
						return true;
					}
				}
				_timeStamp = currentTime;
				_isSent = true;
				peer.SendUserData(_packet);
				return true;
			}

			public bool Clear(NetPeer peer)
			{
				if (_packet != null)
				{
					peer.RecycleAndDeliver(_packet);
					_packet = null;
					return true;
				}
				return false;
			}
		}

		private readonly NetPacket _outgoingAcks;

		private readonly PendingPacket[] _pendingPackets;

		private readonly NetPacket[] _receivedPackets;

		private readonly bool[] _earlyReceived;

		private int _localSeqence;

		private int _remoteSequence;

		private int _localWindowStart;

		private int _remoteWindowStart;

		private bool _mustSendAcks;

		private readonly DeliveryMethod _deliveryMethod;

		private readonly bool _ordered;

		private readonly int _windowSize;

		private const int BitsInByte = 8;

		private readonly byte _id;

		public ReliableChannel(NetPeer peer, bool ordered, byte id)
			: base(peer)
		{
			_id = id;
			_windowSize = 64;
			_ordered = ordered;
			_pendingPackets = new PendingPacket[_windowSize];
			for (int i = 0; i < _pendingPackets.Length; i++)
			{
				_pendingPackets[i] = default(PendingPacket);
			}
			if (_ordered)
			{
				_deliveryMethod = DeliveryMethod.ReliableOrdered;
				_receivedPackets = new NetPacket[_windowSize];
			}
			else
			{
				_deliveryMethod = DeliveryMethod.ReliableUnordered;
				_earlyReceived = new bool[_windowSize];
			}
			_localWindowStart = 0;
			_localSeqence = 0;
			_remoteSequence = 0;
			_remoteWindowStart = 0;
			_outgoingAcks = new NetPacket(PacketProperty.Ack, (_windowSize - 1) / 8 + 2)
			{
				ChannelId = id
			};
		}

		private void ProcessAck(NetPacket packet)
		{
			if (packet.Size != _outgoingAcks.Size)
			{
				return;
			}
			ushort sequence = packet.Sequence;
			int num = NetUtils.RelativeSequenceNumber(_localWindowStart, sequence);
			if (sequence >= 32768 || num < 0 || num >= _windowSize)
			{
				return;
			}
			byte[] rawData = packet.RawData;
			lock (_pendingPackets)
			{
				int num2 = _localWindowStart;
				while (num2 != _localSeqence && NetUtils.RelativeSequenceNumber(num2, sequence) < _windowSize)
				{
					int num3 = num2 % _windowSize;
					int num4 = 4 + num3 / 8;
					int num5 = num3 % 8;
					if ((rawData[num4] & (1 << num5)) == 0)
					{
						if (Peer.NetManager.EnableStatistics)
						{
							Peer.Statistics.IncrementPacketLoss();
							Peer.NetManager.Statistics.IncrementPacketLoss();
						}
					}
					else
					{
						if (num2 == _localWindowStart)
						{
							_localWindowStart = (_localWindowStart + 1) % 32768;
						}
						_pendingPackets[num3].Clear(Peer);
					}
					num2 = (num2 + 1) % 32768;
				}
			}
		}

		protected override bool SendNextPackets()
		{
			if (_mustSendAcks)
			{
				_mustSendAcks = false;
				lock (_outgoingAcks)
				{
					Peer.SendUserData(_outgoingAcks);
				}
			}
			long ticks = DateTime.UtcNow.Ticks;
			bool flag = false;
			lock (_pendingPackets)
			{
				lock (OutgoingQueue)
				{
					while (OutgoingQueue.Count > 0 && NetUtils.RelativeSequenceNumber(_localSeqence, _localWindowStart) < _windowSize)
					{
						NetPacket netPacket = OutgoingQueue.Dequeue();
						netPacket.Sequence = (ushort)_localSeqence;
						netPacket.ChannelId = _id;
						_pendingPackets[_localSeqence % _windowSize].Init(netPacket);
						_localSeqence = (_localSeqence + 1) % 32768;
					}
				}
				for (int num = _localWindowStart; num != _localSeqence; num = (num + 1) % 32768)
				{
					if (_pendingPackets[num % _windowSize].TrySend(ticks, Peer))
					{
						flag = true;
					}
				}
			}
			if (!flag && !_mustSendAcks)
			{
				return OutgoingQueue.Count > 0;
			}
			return true;
		}

		public override bool ProcessPacket(NetPacket packet)
		{
			if (packet.Property == PacketProperty.Ack)
			{
				ProcessAck(packet);
				return false;
			}
			int sequence = packet.Sequence;
			if (sequence >= 32768)
			{
				return false;
			}
			int num = NetUtils.RelativeSequenceNumber(sequence, _remoteWindowStart);
			if (NetUtils.RelativeSequenceNumber(sequence, _remoteSequence) > _windowSize)
			{
				return false;
			}
			if (num < 0)
			{
				return false;
			}
			if (num >= _windowSize * 2)
			{
				return false;
			}
			int num3;
			lock (_outgoingAcks)
			{
				int num4;
				int num5;
				if (num >= _windowSize)
				{
					int num2 = (_remoteWindowStart + num - _windowSize + 1) % 32768;
					_outgoingAcks.Sequence = (ushort)num2;
					while (_remoteWindowStart != num2)
					{
						num3 = _remoteWindowStart % _windowSize;
						num4 = 4 + num3 / 8;
						num5 = num3 % 8;
						_outgoingAcks.RawData[num4] &= (byte)(~(1 << num5));
						_remoteWindowStart = (_remoteWindowStart + 1) % 32768;
					}
				}
				_mustSendAcks = true;
				num3 = sequence % _windowSize;
				num4 = 4 + num3 / 8;
				num5 = num3 % 8;
				if ((_outgoingAcks.RawData[num4] & (1 << num5)) != 0)
				{
					AddToPeerChannelSendQueue();
					return false;
				}
				_outgoingAcks.RawData[num4] |= (byte)(1 << num5);
			}
			AddToPeerChannelSendQueue();
			if (sequence == _remoteSequence)
			{
				Peer.AddReliablePacket(_deliveryMethod, packet);
				_remoteSequence = (_remoteSequence + 1) % 32768;
				if (_ordered)
				{
					NetPacket p;
					while ((p = _receivedPackets[_remoteSequence % _windowSize]) != null)
					{
						_receivedPackets[_remoteSequence % _windowSize] = null;
						Peer.AddReliablePacket(_deliveryMethod, p);
						_remoteSequence = (_remoteSequence + 1) % 32768;
					}
				}
				else
				{
					while (_earlyReceived[_remoteSequence % _windowSize])
					{
						_earlyReceived[_remoteSequence % _windowSize] = false;
						_remoteSequence = (_remoteSequence + 1) % 32768;
					}
				}
				return true;
			}
			if (_ordered)
			{
				_receivedPackets[num3] = packet;
			}
			else
			{
				_earlyReceived[num3] = true;
				Peer.AddReliablePacket(_deliveryMethod, packet);
			}
			return true;
		}
	}
	internal sealed class SequencedChannel : BaseChannel
	{
		private int _localSequence;

		private ushort _remoteSequence;

		private readonly bool _reliable;

		private NetPacket _lastPacket;

		private readonly NetPacket _ackPacket;

		private bool _mustSendAck;

		private readonly byte _id;

		private long _lastPacketSendTime;

		public SequencedChannel(NetPeer peer, bool reliable, byte id)
			: base(peer)
		{
			_id = id;
			_reliable = reliable;
			if (_reliable)
			{
				_ackPacket = new NetPacket(PacketProperty.Ack, 0)
				{
					ChannelId = id
				};
			}
		}

		protected override bool SendNextPackets()
		{
			if (_reliable && OutgoingQueue.Count == 0)
			{
				long ticks = DateTime.UtcNow.Ticks;
				if ((double)(ticks - _lastPacketSendTime) >= Peer.ResendDelay * 10000.0)
				{
					NetPacket lastPacket = _lastPacket;
					if (lastPacket != null)
					{
						_lastPacketSendTime = ticks;
						Peer.SendUserData(lastPacket);
					}
				}
			}
			else
			{
				lock (OutgoingQueue)
				{
					while (OutgoingQueue.Count > 0)
					{
						NetPacket netPacket = OutgoingQueue.Dequeue();
						_localSequence = (_localSequence + 1) % 32768;
						netPacket.Sequence = (ushort)_localSequence;
						netPacket.ChannelId = _id;
						Peer.SendUserData(netPacket);
						if (_reliable && OutgoingQueue.Count == 0)
						{
							_lastPacketSendTime = DateTime.UtcNow.Ticks;
							_lastPacket = netPacket;
						}
						else
						{
							Peer.NetManager.PoolRecycle(netPacket);
						}
					}
				}
			}
			if (_reliable && _mustSendAck)
			{
				_mustSendAck = false;
				_ackPacket.Sequence = _remoteSequence;
				Peer.SendUserData(_ackPacket);
			}
			return _lastPacket != null;
		}

		public override bool ProcessPacket(NetPacket packet)
		{
			if (packet.IsFragmented)
			{
				return false;
			}
			if (packet.Property == PacketProperty.Ack)
			{
				if (_reliable && _lastPacket != null && packet.Sequence == _lastPacket.Sequence)
				{
					_lastPacket = null;
				}
				return false;
			}
			int num = NetUtils.RelativeSequenceNumber(packet.Sequence, _remoteSequence);
			bool result = false;
			if (packet.Sequence < 32768 && num > 0)
			{
				if (Peer.NetManager.EnableStatistics)
				{
					Peer.Statistics.AddPacketLoss(num - 1);
					Peer.NetManager.Statistics.AddPacketLoss(num - 1);
				}
				_remoteSequence = packet.Sequence;
				Peer.NetManager.CreateReceiveEvent(packet, (!_reliable) ? DeliveryMethod.Sequenced : DeliveryMethod.ReliableSequenced, (byte)(packet.ChannelId / 4), 4, Peer);
				result = true;
			}
			if (_reliable)
			{
				_mustSendAck = true;
				AddToPeerChannelSendQueue();
			}
			return result;
		}
	}
	internal static class Trimming
	{
		internal const DynamicallyAccessedMemberTypes SerializerMemberTypes = DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties;
	}
}
namespace LiteNetLib.Utils
{
	public static class CRC32C
	{
		public const int ChecksumSize = 4;

		private const uint Poly = 2197175160u;

		private static readonly uint[] Table;

		static CRC32C()
		{
			if (Sse42.IsSupported || Crc32.IsSupported)
			{
				return;
			}
			Table = NetUtils.AllocatePinnedUninitializedArray<uint>(4096);
			for (uint num = 0u; num < 256; num++)
			{
				uint num2 = num;
				for (int i = 0; i < 16; i++)
				{
					for (int j = 0; j < 8; j++)
					{
						num2 = (((num2 & 1) == 1) ? (0x82F63B78u ^ (num2 >> 1)) : (num2 >> 1));
					}
					Table[i * 256 + num] = num2;
				}
			}
		}

		public static uint Compute(byte[] input, int offset, int length)
		{
			uint num = uint.MaxValue;
			if (Sse42.IsSupported)
			{
				ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(input, offset, length);
				int num2 = 0;
				if (Sse42.X64.IsSupported && readOnlySpan.Length > 8)
				{
					num2 = readOnlySpan.Length / 8 * 8;
					ReadOnlySpan<ulong> readOnlySpan2 = MemoryMarshal.Cast<byte, ulong>(readOnlySpan.Slice(0, num2));
					ulong num3 = num;
					for (int i = 0; i < readOnlySpan2.Length; i++)
					{
						num3 = Sse42.X64.Crc32(num3, readOnlySpan2[i]);
					}
					num = (uint)num3;
				}
				else if (readOnlySpan.Length > 4)
				{
					num2 = readOnlySpan.Length / 4 * 4;
					ReadOnlySpan<uint> readOnlySpan3 = MemoryMarshal.Cast<byte, uint>(readOnlySpan.Slice(0, num2));
					for (int j = 0; j < readOnlySpan3.Length; j++)
					{
						num = Sse42.Crc32(num, readOnlySpan3[j]);
					}
				}
				for (int k = num2; k < readOnlySpan.Length; k++)
				{
					num = Sse42.Crc32(num, readOnlySpan[k]);
				}
				return num ^ 0xFFFFFFFFu;
			}
			if (Crc32.IsSupported)
			{
				ReadOnlySpan<byte> readOnlySpan4 = new ReadOnlySpan<byte>(input, offset, length);
				int num4 = 0;
				if (Crc32.Arm64.IsSupported && readOnlySpan4.Length > 8)
				{
					num4 = readOnlySpan4.Length / 8 * 8;
					ReadOnlySpan<ulong> readOnlySpan5 = MemoryMarshal.Cast<byte, ulong>(readOnlySpan4.Slice(0, num4));
					for (int l = 0; l < readOnlySpan5.Length; l++)
					{
						num = Crc32.Arm64.ComputeCrc32C(num, readOnlySpan5[l]);
					}
				}
				else if (readOnlySpan4.Length > 4)
				{
					num4 = readOnlySpan4.Length / 4 * 4;
					ReadOnlySpan<uint> readOnlySpan6 = MemoryMarshal.Cast<byte, uint>(readOnlySpan4.Slice(0, num4));
					for (int m = 0; m < readOnlySpan6.Length; m++)
					{
						num = Crc32.ComputeCrc32C(num, readOnlySpan6[m]);
					}
				}
				for (int n = num4; n < readOnlySpan4.Length; n++)
				{
					num = Crc32.ComputeCrc32C(num, readOnlySpan4[n]);
				}
				return num ^ 0xFFFFFFFFu;
			}
			while (length >= 16)
			{
				uint num5 = Table[768 + input[offset + 12]] ^ Table[512 + input[offset + 13]] ^ Table[256 + input[offset + 14]] ^ Table[input[offset + 15]];
				uint num6 = Table[1792 + input[offset + 8]] ^ Table[1536 + input[offset + 9]] ^ Table[1280 + input[offset + 10]] ^ Table[1024 + input[offset + 11]];
				uint num7 = Table[2816 + input[offset + 4]] ^ Table[2560 + input[offset + 5]] ^ Table[2304 + input[offset + 6]] ^ Table[2048 + input[offset + 7]];
				num = Table[3840 + ((byte)num ^ input[offset])] ^ Table[3584 + ((byte)(num >> 8) ^ input[offset + 1])] ^ Table[3328 + ((byte)(num >> 16) ^ input[offset + 2])] ^ Table[3072 + ((num >> 24) ^ input[offset + 3])] ^ num7 ^ num6 ^ num5;
				offset += 16;
				length -= 16;
			}
			while (--length >= 0)
			{
				num = Table[(byte)(num ^ input[offset++])] ^ (num >> 8);
			}
			return num ^ 0xFFFFFFFFu;
		}
	}
	public static class FastBitConverter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void GetBytes<T>(byte[] bytes, int startIndex, T value)
		{
			if (bytes.Length < startIndex + Unsafe.SizeOf<T>())
			{
				ThrowIndexOutOfRangeException();
			}
			Unsafe.As<byte, T>(ref bytes[startIndex]) = value;
		}

		private static void ThrowIndexOutOfRangeException()
		{
			throw new IndexOutOfRangeException();
		}
	}
	public interface INetSerializable
	{
		void Serialize(NetDataWriter writer);

		void Deserialize(NetDataReader reader);
	}
	public class NetDataReader
	{
		protected byte[] _data;

		protected int _position;

		protected int _dataSize;

		private int _offset;

		public byte[] RawData
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _data;
			}
		}

		public int RawDataSize
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _dataSize;
			}
		}

		public int UserDataOffset
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _offset;
			}
		}

		public int UserDataSize
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _dataSize - _offset;
			}
		}

		public bool IsNull
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _data == null;
			}
		}

		public int Position
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _position;
			}
		}

		public bool EndOfData
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _position == _dataSize;
			}
		}

		public int AvailableBytes
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _dataSize - _position;
			}
		}

		public void SkipBytes(int count)
		{
			_position += count;
		}

		public void SetPosition(int position)
		{
			_position = position;
		}

		public void SetSource(NetDataWriter dataWriter)
		{
			_data = dataWriter.Data;
			_position = 0;
			_offset = 0;
			_dataSize = dataWriter.Length;
		}

		public void SetSource(byte[] source)
		{
			_data = source;
			_position = 0;
			_offset = 0;
			_dataSize = source.Length;
		}

		public void SetSource(byte[] source, int offset, int maxSize)
		{
			_data = source;
			_position = offset;
			_offset = offset;
			_dataSize = maxSize;
		}

		public NetDataReader()
		{
		}

		public NetDataReader(NetDataWriter writer)
		{
			SetSource(writer);
		}

		public NetDataReader(byte[] source)
		{
			SetSource(source);
		}

		public NetDataReader(byte[] source, int offset, int maxSize)
		{
			SetSource(source, offset, maxSize);
		}

		public void Get<T>(out T result) where T : struct, INetSerializable
		{
			result = default(T);
			result.Deserialize(this);
		}

		public void Get<T>(out T result, Func<T> constructor) where T : class, INetSerializable
		{
			result = constructor();
			result.Deserialize(this);
		}

		public void Get(out IPEndPoint result)
		{
			result = GetNetEndPoint();
		}

		public void Get(out byte result)
		{
			result = GetByte();
		}

		public void Get(out sbyte result)
		{
			result = (sbyte)GetByte();
		}

		public void Get(out bool result)
		{
			result = GetBool();
		}

		public void Get(out char result)
		{
			result = GetChar();
		}

		public void Get(out ushort result)
		{
			result = GetUShort();
		}

		public void Get(out short result)
		{
			result = GetShort();
		}

		public void Get(out ulong result)
		{
			result = GetULong();
		}

		public void Get(out long result)
		{
			result = GetLong();
		}

		public void Get(out uint result)
		{
			result = GetUInt();
		}

		public void Get(out int result)
		{
			result = GetInt();
		}

		public void Get(out double result)
		{
			result = GetDouble();
		}

		public void Get(out float result)
		{
			result = GetFloat();
		}

		public void Get(out string result)
		{
			result = GetString();
		}

		public void Get(out string result, int maxLength)
		{
			result = GetString(maxLength);
		}

		public void Get(out Guid result)
		{
			result = GetGuid();
		}

		public IPEndPoint GetNetEndPoint()
		{
			string @string = GetString(1000);
			int @int = GetInt();
			return NetUtils.MakeEndPoint(@string, @int);
		}

		public byte GetByte()
		{
			byte result = _data[_position];
			_position++;
			return result;
		}

		public sbyte GetSByte()
		{
			return (sbyte)GetByte();
		}

		public T[] GetArray<T>(ushort size)
		{
			ushort num = BitConverter.ToUInt16(_data, _position);
			_position += 2;
			T[] array = new T[num];
			num *= size;
			Buffer.BlockCopy(_data, _position, array, 0, num);
			_position += num;
			return array;
		}

		public T[] GetArray<T>() where T : INetSerializable, new()
		{
			ushort num = BitConverter.ToUInt16(_data, _position);
			_position += 2;
			T[] array = new T[num];
			for (int i = 0; i < num; i++)
			{
				T val = new T();
				val.Deserialize(this);
				array[i] = val;
			}
			return array;
		}

		public T[] GetArray<T>(Func<T> constructor) where T : class, INetSerializable
		{
			ushort num = BitConverter.ToUInt16(_data, _position);
			_position += 2;
			T[] array = new T[num];
			for (int i = 0; i < num; i++)
			{
				Get(out array[i], constructor);
			}
			return array;
		}

		public bool[] GetBoolArray()
		{
			return GetArray<bool>(1);
		}

		public ushort[] GetUShortArray()
		{
			return GetArray<ushort>(2);
		}

		public short[] GetShortArray()
		{
			return GetArray<short>(2);
		}

		public int[] GetIntArray()
		{
			return GetArray<int>(4);
		}

		public uint[] GetUIntArray()
		{
			return GetArray<uint>(4);
		}

		public float[] GetFloatArray()
		{
			return GetArray<float>(4);
		}

		public double[] GetDoubleArray()
		{
			return GetArray<double>(8);
		}

		public long[] GetLongArray()
		{
			return GetArray<long>(8);
		}

		public ulong[] GetULongArray()
		{
			return GetArray<ulong>(8);
		}

		public string[] GetStringArray()
		{
			ushort uShort = GetUShort();
			string[] array = new string[uShort];
			for (int i = 0; i < uShort; i++)
			{
				array[i] = GetString();
			}
			return array;
		}

		public string[] GetStringArray(int maxStringLength)
		{
			ushort uShort = GetUShort();
			string[] array = new string[uShort];
			for (int i = 0; i < uShort; i++)
			{
				array[i] = GetString(maxStringLength);
			}
			return array;
		}

		public bool GetBool()
		{
			return GetByte() == 1;
		}

		public char GetChar()
		{
			return (char)GetUShort();
		}

		public ushort GetUShort()
		{
			ushort result = BitConverter.ToUInt16(_data, _position);
			_position += 2;
			return result;
		}

		public short GetShort()
		{
			short result = BitConverter.ToInt16(_data, _position);
			_position += 2;
			return result;
		}

		public long GetLong()
		{
			long result = BitConverter.ToInt64(_data, _position);
			_position += 8;
			return result;
		}

		public ulong GetULong()
		{
			ulong result = BitConverter.ToUInt64(_data, _position);
			_position += 8;
			return result;
		}

		public int GetInt()
		{
			int result = BitConverter.ToInt32(_data, _position);
			_position += 4;
			return result;
		}

		public uint GetUInt()
		{
			uint result = BitConverter.ToUInt32(_data, _position);
			_position += 4;
			return result;
		}

		public float GetFloat()
		{
			float result = BitConverter.ToSingle(_data, _position);
			_position += 4;
			return result;
		}

		public double GetDouble()
		{
			double result = BitConverter.ToDouble(_data, _position);
			_position += 8;
			return result;
		}

		public string GetString(int maxLength)
		{
			ushort uShort = GetUShort();
			if (uShort == 0)
			{
				return string.Empty;
			}
			int num = uShort - 1;
			string result = ((maxLength > 0 && NetDataWriter.uTF8Encoding.Value.GetCharCount(_data, _position, num) > maxLength) ? string.Empty : NetDataWriter.uTF8Encoding.Value.GetString(_data, _position, num));
			_position += num;
			return result;
		}

		public string GetString()
		{
			ushort uShort = GetUShort();
			if (uShort == 0)
			{
				return string.Empty;
			}
			int num = uShort - 1;
			string @string = NetDataWriter.uTF8Encoding.Value.GetString(_data, _position, num);
			_position += num;
			return @string;
		}

		public string GetLargeString()
		{
			int @int = GetInt();
			if (@int <= 0)
			{
				return string.Empty;
			}
			string @string = NetDataWriter.uTF8Encoding.Value.GetString(_data, _position, @int);
			_position += @int;
			return @string;
		}

		public Guid GetGuid()
		{
			Guid result = new Guid(_data.AsSpan(_position, 16));
			_position += 16;
			return result;
		}

		public ArraySegment<byte> GetBytesSegment(int count)
		{
			ArraySegment<byte> result = new ArraySegment<byte>(_data, _position, count);
			_position += count;
			return result;
		}

		public ArraySegment<byte> GetRemainingBytesSegment()
		{
			ArraySegment<byte> result = new ArraySegment<byte>(_data, _position, AvailableBytes);
			_position = _data.Length;
			return result;
		}

		public T Get<T>() where T : struct, INetSerializable
		{
			T result = default(T);
			result.Deserialize(this);
			return result;
		}

		public T Get<T>(Func<T> constructor) where T : class, INetSerializable
		{
			T val = constructor();
			val.Deserialize(this);
			return val;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySpan<byte> GetRemainingBytesSpan()
		{
			return new ReadOnlySpan<byte>(_data, _position, _dataSize - _position);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlyMemory<byte> GetRemainingBytesMemory()
		{
			return new ReadOnlyMemory<byte>(_data, _position, _dataSize - _position);
		}

		public byte[] GetRemainingBytes()
		{
			byte[] array = new byte[AvailableBytes];
			Buffer.BlockCopy(_data, _position, array, 0, AvailableBytes);
			_position = _data.Length;
			return array;
		}

		public void GetBytes(byte[] destination, int start, int count)
		{
			Buffer.BlockCopy(_data, _position, destination, start, count);
			_position += count;
		}

		public void GetBytes(byte[] destination, int count)
		{
			Buffer.BlockCopy(_data, _position, destination, 0, count);
			_position += count;
		}

		public sbyte[] GetSBytesWithLength()
		{
			return GetArray<sbyte>(1);
		}

		public byte[] GetBytesWithLength()
		{
			return GetArray<byte>(1);
		}

		public byte PeekByte()
		{
			return _data[_position];
		}

		public sbyte PeekSByte()
		{
			return (sbyte)_data[_position];
		}

		public bool PeekBool()
		{
			return _data[_position] == 1;
		}

		public char PeekChar()
		{
			return (char)PeekUShort();
		}

		public ushort PeekUShort()
		{
			return BitConverter.ToUInt16(_data, _position);
		}

		public short PeekShort()
		{
			return BitConverter.ToInt16(_data, _position);
		}

		public long PeekLong()
		{
			return BitConverter.ToInt64(_data, _position);
		}

		public ulong PeekULong()
		{
			return BitConverter.ToUInt64(_data, _position);
		}

		public int PeekInt()
		{
			return BitConverter.ToInt32(_data, _position);
		}

		public uint PeekUInt()
		{
			return BitConverter.ToUInt32(_data, _position);
		}

		public float PeekFloat()
		{
			return BitConverter.ToSingle(_data, _position);
		}

		public double PeekDouble()
		{
			return BitConverter.ToDouble(_data, _position);
		}

		public string PeekString(int maxLength)
		{
			ushort num = PeekUShort();
			if (num == 0)
			{
				return string.Empty;
			}
			int count = num - 1;
			if (maxLength <= 0 || NetDataWriter.uTF8Encoding.Value.GetCharCount(_data, _position + 2, count) <= maxLength)
			{
				return NetDataWriter.uTF8Encoding.Value.GetString(_data, _position + 2, count);
			}
			return string.Empty;
		}

		public string PeekString()
		{
			ushort num = PeekUShort();
			if (num == 0)
			{
				return string.Empty;
			}
			int count = num - 1;
			return NetDataWriter.uTF8Encoding.Value.GetString(_data, _position + 2, count);
		}

		public bool TryGetByte(out byte result)
		{
			if (AvailableBytes >= 1)
			{
				result = GetByte();
				return true;
			}
			result = 0;
			return false;
		}

		public bool TryGetSByte(out sbyte result)
		{
			if (AvailableBytes >= 1)
			{
				result = GetSByte();
				return true;
			}
			result = 0;
			return false;
		}

		public bool TryGetBool(out bool result)
		{
			if (AvailableBytes >= 1)
			{
				result = GetBool();
				return true;
			}
			result = false;
			return false;
		}

		public bool TryGetChar(out char result)
		{
			if (!TryGetUShort(out var result2))
			{
				result = '\0';
				return false;
			}
			result = (char)result2;
			return true;
		}

		public bool TryGetShort(out short result)
		{
			if (AvailableBytes >= 2)
			{
				result = GetShort();
				return true;
			}
			result = 0;
			return false;
		}

		public bool TryGetUShort(out ushort result)
		{
			if (AvailableBytes >= 2)
			{
				result = GetUShort();
				return true;
			}
			result = 0;
			return false;
		}

		public bool TryGetInt(out int result)
		{
			if (AvailableBytes >= 4)
			{
				result = GetInt();
				return true;
			}
			result = 0;
			return false;
		}

		public bool TryGetUInt(out uint result)
		{
			if (AvailableBytes >= 4)
			{
				result = GetUInt();
				return true;
			}
			result = 0u;
			return false;
		}

		public bool TryGetLong(out long result)
		{
			if (AvailableBytes >= 8)
			{
				result = GetLong();
				return true;
			}
			result = 0L;
			return false;
		}

		public bool TryGetULong(out ulong result)
		{
			if (AvailableBytes >= 8)
			{
				result = GetULong();
				return true;
			}
			result = 0uL;
			return false;
		}

		public bool TryGetFloat(out float result)
		{
			if (AvailableBytes >= 4)
			{
				result = GetFloat();
				return true;
			}
			result = 0f;
			return false;
		}

		public bool TryGetDouble(out double result)
		{
			if (AvailableBytes >= 8)
			{
				result = GetDouble();
				return true;
			}
			result = 0.0;
			return false;
		}

		public bool TryGetString(out string result)
		{
			if (AvailableBytes >= 2)
			{
				ushort num = PeekUShort();
				if (AvailableBytes >= num + 1)
				{
					result = GetString();
					return true;
				}
			}
			result = null;
			return false;
		}

		public bool TryGetStringArray(out string[] result)
		{
			if (!TryGetUShort(out var result2))
			{
				result = null;
				return false;
			}
			result = new string[result2];
			for (int i = 0; i < result2; i++)
			{
				if (!TryGetString(out result[i]))
				{
					result = null;
					return false;
				}
			}
			return true;
		}

		public bool TryGetBytesWithLength(out byte[] result)
		{
			if (AvailableBytes >= 2)
			{
				ushort num = PeekUShort();
				if (num >= 0 && AvailableBytes >= 2 + num)
				{
					result = GetBytesWithLength();
					return true;
				}
			}
			result = null;
			return false;
		}

		public void Clear()
		{
			_position = 0;
			_dataSize = 0;
			_data = null;
		}
	}
	public class NetDataWriter
	{
		protected byte[] _data;

		protected int _position;

		private const int InitialSize = 64;

		private readonly bool _autoResize;

		public static readonly ThreadLocal<UTF8Encoding> uTF8Encoding = new ThreadLocal<UTF8Encoding>(() => new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true));

		public int Capacity
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _data.Length;
			}
		}

		public byte[] Data
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _data;
			}
		}

		public int Length
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _position;
			}
		}

		public ReadOnlySpan<byte> AsReadOnlySpan()
		{
			return new ReadOnlySpan<byte>(_data, 0, _position);
		}

		public NetDataWriter()
			: this(autoResize: true, 64)
		{
		}

		public NetDataWriter(bool autoResize)
			: this(autoResize, 64)
		{
		}

		public NetDataWriter(bool autoResize, int initialSize)
		{
			_data = new byte[initialSize];
			_autoResize = autoResize;
		}

		public static NetDataWriter FromBytes(byte[] bytes, bool copy)
		{
			if (copy)
			{
				NetDataWriter netDataWriter = new NetDataWriter(autoResize: true, bytes.Length);
				netDataWriter.Put(bytes);
				return netDataWriter;
			}
			return new NetDataWriter(autoResize: true, 0)
			{
				_data = bytes,
				_position = bytes.Length
			};
		}

		public static NetDataWriter FromBytes(byte[] bytes, int offset, int length)
		{
			NetDataWriter netDataWriter = new NetDataWriter(autoResize: true, bytes.Length);
			netDataWriter.Put(bytes, offset, length);
			return netDataWriter;
		}

		public static NetDataWriter FromString(string value)
		{
			NetDataWriter netDataWriter = new NetDataWriter();
			netDataWriter.Put(value);
			return netDataWriter;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void ResizeIfNeed(int newSize)
		{
			if (_data.Length < newSize)
			{
				Array.Resize(ref _data, Math.Max(newSize, _data.Length * 2));
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void EnsureFit(int additionalSize)
		{
			if (_data.Length < _position + additionalSize)
			{
				Array.Resize(ref _data, Math.Max(_position + additionalSize, _data.Length * 2));
			}
		}

		public void Reset(int size)
		{
			ResizeIfNeed(size);
			_position = 0;
		}

		public void Reset()
		{
			_position = 0;
		}

		public byte[] CopyData()
		{
			byte[] array = new byte[_position];
			Buffer.BlockCopy(_data, 0, array, 0, _position);
			return array;
		}

		public int SetPosition(int position)
		{
			int position2 = _position;
			_position = position;
			return position2;
		}

		public void Put(float value)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + 4);
			}
			FastBitConverter.GetBytes(_data, _position, value);
			_position += 4;
		}

		public void Put(double value)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + 8);
			}
			FastBitConverter.GetBytes(_data, _position, value);
			_position += 8;
		}

		public void Put(long value)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + 8);
			}
			FastBitConverter.GetBytes(_data, _position, value);
			_position += 8;
		}

		public void Put(ulong value)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + 8);
			}
			FastBitConverter.GetBytes(_data, _position, value);
			_position += 8;
		}

		public void Put(int value)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + 4);
			}
			FastBitConverter.GetBytes(_data, _position, value);
			_position += 4;
		}

		public void Put(uint value)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + 4);
			}
			FastBitConverter.GetBytes(_data, _position, value);
			_position += 4;
		}

		public void Put(char value)
		{
			Put((ushort)value);
		}

		public void Put(ushort value)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + 2);
			}
			FastBitConverter.GetBytes(_data, _position, value);
			_position += 2;
		}

		public void Put(short value)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + 2);
			}
			FastBitConverter.GetBytes(_data, _position, value);
			_position += 2;
		}

		public void Put(sbyte value)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + 1);
			}
			_data[_position] = (byte)value;
			_position++;
		}

		public void Put(byte value)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + 1);
			}
			_data[_position] = value;
			_position++;
		}

		public void Put(Guid value)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + 16);
			}
			value.TryWriteBytes(_data.AsSpan(_position));
			_position += 16;
		}

		public void Put(byte[] data, int offset, int length)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + length);
			}
			Buffer.BlockCopy(data, offset, _data, _position, length);
			_position += length;
		}

		public void Put(byte[] data)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + data.Length);
			}
			Buffer.BlockCopy(data, 0, _data, _position, data.Length);
			_position += data.Length;
		}

		public void PutSBytesWithLength(sbyte[] data, int offset, ushort length)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + 2 + length);
			}
			FastBitConverter.GetBytes(_data, _position, length);
			Buffer.BlockCopy(data, offset, _data, _position + 2, length);
			_position += 2 + length;
		}

		public void PutSBytesWithLength(sbyte[] data)
		{
			PutArray(data, 1);
		}

		public void PutBytesWithLength(byte[] data, int offset, ushort length)
		{
			if (_autoResize)
			{
				ResizeIfNeed(_position + 2 + length);
			}
			FastBitConverter.GetBytes(_data, _position, length);
			Buffer.BlockCopy(data, offset, _data, _position + 2, length);
			_position += 2 + length;
		}

		public void PutBytesWithLength(byte[] data)
		{
			PutArray(data, 1);
		}

		public void Put(bool value)
		{
			Put(value ? ((byte)1) : ((byte)0));
		}

		public void PutArray(Array arr, int sz)
		{
			ushort num = (ushort)((arr != null) ? ((ushort)arr.Length) : 0);
			sz *= num;
			if (_autoResize)
			{
				ResizeIfNeed(_position + sz + 2);
			}
			FastBitConverter.GetBytes(_data, _position, num);
			if (arr != null)
			{
				Buffer.BlockCopy(arr, 0, _data, _position + 2, sz);
			}
			_position += sz + 2;
		}

		public void PutArray(float[] value)
		{
			PutArray(value, 4);
		}

		public void PutArray(double[] value)
		{
			PutArray(value, 8);
		}

		public void PutArray(long[] value)
		{
			PutArray(value, 8);
		}

		public void PutArray(ulong[] value)
		{
			PutArray(value, 8);
		}

		public void PutArray(int[] value)
		{
			PutArray(value, 4);
		}

		public void PutArray(uint[] value)
		{
			PutArray(value, 4);
		}

		public void PutArray(ushort[] value)
		{
			PutArray(value, 2);
		}

		public void PutArray(short[] value)
		{
			PutArray(value, 2);
		}

		public void PutArray(bool[] value)
		{
			PutArray(value, 1);
		}

		public void PutArray(string[] value)
		{
			ushort num = (ushort)((value != null) ? ((ushort)value.Length) : 0);
			Put(num);
			for (int i = 0; i < num; i++)
			{
				Put(value[i]);
			}
		}

		public void PutArray(string[] value, int strMaxLength)
		{
			ushort num = (ushort)((value != null) ? ((ushort)value.Length) : 0);
			Put(num);
			for (int i = 0; i < num; i++)
			{
				Put(value[i], strMaxLength);
			}
		}

		public void PutArray<T>(T[] value) where T : INetSerializable, new()
		{
			ushort num = (ushort)((value != null) ? ((uint)value.Length) : 0u);
			Put(num);
			for (int i = 0; i < num; i++)
			{
				value[i].Serialize(this);
			}
		}

		public void Put(IPEndPoint endPoint)
		{
			Put(endPoint.Address.ToString());
			Put(endPoint.Port);
		}

		public void PutLargeString(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				Put(0);
				return;
			}
			int byteCount = uTF8Encoding.Value.GetByteCount(value);
			if (byteCount == 0)
			{
				Put(0);
				return;
			}
			Put(byteCount);
			if (_autoResize)
			{
				ResizeIfNeed(_position + byteCount);
			}
			uTF8Encoding.Value.GetBytes(value, 0, byteCount, _data, _position);
			_position += byteCount;
		}

		public void Put(string value)
		{
			Put(value, 0);
		}

		public void Put(string value, int maxLength)
		{
			if (string.IsNullOrEmpty(value))
			{
				Put((ushort)0);
				return;
			}
			int charCount = ((maxLength > 0 && value.Length > maxLength) ? maxLength : value.Length);
			int maxByteCount = uTF8Encoding.Value.GetMaxByteCount(charCount);
			if (_autoResize)
			{
				ResizeIfNeed(_position + maxByteCount + 2);
			}
			int bytes = uTF8Encoding.Value.GetBytes(value, 0, charCount, _data, _position + 2);
			if (bytes == 0)
			{
				Put((ushort)0);
				return;
			}
			Put(checked((ushort)(bytes + 1)));
			_position += bytes;
		}

		public void Put<T>(T obj) where T : INetSerializable
		{
			obj.Serialize(this);
		}
	}
	public class NetPacketProcessor
	{
		private static class HashCache<T>
		{
			public static readonly ulong Id;

			static HashCache()
			{
				ulong num = 14695981039346656037uL;
				string text = typeof(T).ToString();
				for (int i = 0; i < text.Length; i++)
				{
					num ^= text[i];
					num *= 1099511628211L;
				}
				Id = num;
			}
		}

		protected delegate void SubscribeDelegate(NetDataReader reader, object userData);

		private readonly NetSerializer _netSerializer;

		private readonly Dictionary<ulong, SubscribeDelegate> _callbacks = new Dictionary<ulong, SubscribeDelegate>();

		public NetPacketProcessor()
		{
			_netSerializer = new NetSerializer();
		}

		public NetPacketProcessor(int maxStringLength)
		{
			_netSerializer = new NetSerializer(maxStringLength);
		}

		protected virtual ulong GetHash<T>()
		{
			return HashCache<T>.Id;
		}

		protected virtual SubscribeDelegate GetCallbackFromData(NetDataReader reader)
		{
			ulong uLong = reader.GetULong();
			if (!_callbacks.TryGetValue(uLong, out var value))
			{
				throw new ParseException("Undefined packet in NetDataReader");
			}
			return value;
		}

		protected virtual void WriteHash<T>(NetDataWriter writer)
		{
			writer.Put(GetHash<T>());
		}

		public void RegisterNestedType<T>() where T : struct, INetSerializable
		{
			_netSerializer.RegisterNestedType<T>();
		}

		public void RegisterNestedType<T>(Action<NetDataWriter, T> writeDelegate, Func<NetDataReader, T> readDelegate)
		{
			_netSerializer.RegisterNestedType(writeDelegate, readDelegate);
		}

		public void RegisterNestedType<T>(Func<T> constructor) where T : class, INetSerializable
		{
			_netSerializer.RegisterNestedType(constructor);
		}

		public void ReadAllPackets(NetDataReader reader)
		{
			while (reader.AvailableBytes > 0)
			{
				ReadPacket(reader);
			}
		}

		public void ReadAllPackets(NetDataReader reader, object userData)
		{
			while (reader.AvailableBytes > 0)
			{
				ReadPacket(reader, userData);
			}
		}

		public void ReadPacket(NetDataReader reader)
		{
			ReadPacket(reader, null);
		}

		public void Write<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(NetDataWriter writer, T packet) where T : class, new()
		{
			WriteHash<T>(writer);
			_netSerializer.Serialize(writer, packet);
		}

		public void WriteNetSerializable<T>(NetDataWriter writer, ref T packet) where T : INetSerializable
		{
			WriteHash<T>(writer);
			packet.Serialize(writer);
		}

		public void ReadPacket(NetDataReader reader, object userData)
		{
			GetCallbackFromData(reader)(reader, userData);
		}

		public void Subscribe<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Action<T> onReceive, Func<T> packetConstructor) where T : class, new()
		{
			_netSerializer.Register<T>();
			_callbacks[GetHash<T>()] = delegate(NetDataReader reader, object userData)
			{
				T val = packetConstructor();
				_netSerializer.Deserialize(reader, val);
				onReceive(val);
			};
		}

		public void Subscribe<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T, TUserData>(Action<T, TUserData> onReceive, Func<T> packetConstructor) where T : class, new()
		{
			_netSerializer.Register<T>();
			_callbacks[GetHash<T>()] = delegate(NetDataReader reader, object userData)
			{
				T val = packetConstructor();
				_netSerializer.Deserialize(reader, val);
				onReceive(val, (TUserData)userData);
			};
		}

		public void SubscribeReusable<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Action<T> onReceive) where T : class, new()
		{
			_netSerializer.Register<T>();
			T reference = new T();
			_callbacks[GetHash<T>()] = delegate(NetDataReader reader, object userData)
			{
				_netSerializer.Deserialize(reader, reference);
				onReceive(reference);
			};
		}

		public void SubscribeReusable<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T, TUserData>(Action<T, TUserData> onReceive) where T : class, new()
		{
			_netSerializer.Register<T>();
			T reference = new T();
			_callbacks[GetHash<T>()] = delegate(NetDataReader reader, object userData)
			{
				_netSerializer.Deserialize(reader, reference);
				onReceive(reference, (TUserData)userData);
			};
		}

		public void SubscribeNetSerializable<T, TUserData>(Action<T, TUserData> onReceive, Func<T> packetConstructor) where T : INetSerializable
		{
			_callbacks[GetHash<T>()] = delegate(NetDataReader reader, object userData)
			{
				T arg = packetConstructor();
				arg.Deserialize(reader);
				onReceive(arg, (TUserData)userData);
			};
		}

		public void SubscribeNetSerializable<T>(Action<T> onReceive, Func<T> packetConstructor) where T : INetSerializable
		{
			_callbacks[GetHash<T>()] = delegate(NetDataReader reader, object userData)
			{
				T obj = packetConstructor();
				obj.Deserialize(reader);
				onReceive(obj);
			};
		}

		public void SubscribeNetSerializable<T, TUserData>(Action<T, TUserData> onReceive) where T : INetSerializable, new()
		{
			T reference = new T();
			_callbacks[GetHash<T>()] = delegate(NetDataReader reader, object userData)
			{
				reference.Deserialize(reader);
				onReceive(reference, (TUserData)userData);
			};
		}

		public void SubscribeNetSerializable<T>(Action<T> onReceive) where T : INetSerializable, new()
		{
			T reference = new T();
			_callbacks[GetHash<T>()] = delegate(NetDataReader reader, object userData)
			{
				reference.Deserialize(reader);
				onReceive(reference);
			};
		}

		public bool RemoveSubscription<T>()
		{
			return _callbacks.Remove(GetHash<T>());
		}
	}
	public class InvalidTypeException : ArgumentException
	{
		public InvalidTypeException(string message)
			: base(message)
		{
		}
	}
	public class ParseException : Exception
	{
		public ParseException(string message)
			: base(message)
		{
		}
	}
	public class NetSerializer
	{
		private enum CallType
		{
			Basic,
			Array,
			List
		}

		private abstract class FastCall<T>
		{
			public CallType Type;

			public virtual void Init(MethodInfo getMethod, MethodInfo setMethod, CallType type)
			{
				Type = type;
			}

			public abstract void Read(T inf, NetDataReader r);

			public abstract void Write(T inf, NetDataWriter w);

			public abstract void ReadArray(T inf, NetDataReader r);

			public abstract void WriteArray(T inf, NetDataWriter w);

			public abstract void ReadList(T inf, NetDataReader r);

			public abstract void WriteList(T inf, NetDataWriter w);
		}

		private abstract class FastCallSpecific<TClass, TProperty> : FastCall<TClass>
		{
			protected Func<TClass, TProperty> Getter;

			protected Action<TClass, TProperty> Setter;

			protected Func<TClass, TProperty[]> GetterArr;

			protected Action<TClass, TProperty[]> SetterArr;

			protected Func<TClass, List<TProperty>> GetterList;

			protected Action<TClass, List<TProperty>> SetterList;

			public override void ReadArray(TClass inf, NetDataReader r)
			{
				throw new InvalidTypeException("Unsupported type: " + typeof(TProperty)?.ToString() + "[]");
			}

			public override void WriteArray(TClass inf, NetDataWriter w)
			{
				throw new InvalidTypeException("Unsupported type: " + typeof(TProperty)?.ToString() + "[]");
			}

			public override void ReadList(TClass inf, NetDataReader r)
			{
				throw new InvalidTypeException("Unsupported type: List<" + typeof(TProperty)?.ToString() + ">");
			}

			public override void WriteList(TClass inf, NetDataWriter w)
			{
				throw new InvalidTypeException("Unsupported type: List<" + typeof(TProperty)?.ToString() + ">");
			}

			protected TProperty[] ReadArrayHelper(TClass inf, NetDataReader r)
			{
				ushort uShort = r.GetUShort();
				TProperty[] array = GetterArr(inf);
				array = ((array == null || array.Length != uShort) ? new TProperty[uShort] : array);
				SetterArr(inf, array);
				return array;
			}

			protected TProperty[] WriteArrayHelper(TClass inf, NetDataWriter w)
			{
				TProperty[] array = GetterArr(inf);
				w.Put((ushort)array.Length);
				return array;
			}

			protected List<TProperty> ReadListHelper(TClass inf, NetDataReader r, out int len)
			{
				len = r.GetUShort();
				List<TProperty> list = GetterList(inf);
				if (list == null)
				{
					list = new List<TProperty>(len);
					SetterList(inf, list);
				}
				return list;
			}

			protected List<TProperty> WriteListHelper(TClass inf, NetDataWriter w, out int len)
			{
				List<TProperty> list = GetterList(inf);
				if (list == null)
				{
					len = 0;
					w.Put(0);
					return null;
				}
				len = list.Count;
				w.Put((ushort)len);
				return list;
			}

			public override void Init(MethodInfo getMethod, MethodInfo setMethod, CallType type)
			{
				base.Init(getMethod, setMethod, type);
				switch (type)
				{
				case CallType.Array:
					GetterArr = (Func<TClass, TProperty[]>)Delegate.CreateDelegate(typeof(Func<TClass, TProperty[]>), getMethod);
					SetterArr = (Action<TClass, TProperty[]>)Delegate.CreateDelegate(typeof(Action<TClass, TProperty[]>), setMethod);
					break;
				case CallType.List:
					GetterList = (Func<TClass, List<TProperty>>)Delegate.CreateDelegate(typeof(Func<TClass, List<TProperty>>), getMethod);
					SetterList = (Action<TClass, List<TProperty>>)Delegate.CreateDelegate(typeof(Action<TClass, List<TProperty>>), setMethod);
					break;
				default:
					Getter = (Func<TClass, TProperty>)Delegate.CreateDelegate(typeof(Func<TClass, TProperty>), getMethod);
					Setter = (Action<TClass, TProperty>)Delegate.CreateDelegate(typeof(Action<TClass, TProperty>), setMethod);
					break;
				}
			}
		}

		private abstract class FastCallSpecificAuto<TClass, TProperty> : FastCallSpecific<TClass, TProperty>
		{
			protected abstract void ElementRead(NetDataReader r, out TProperty prop);

			protected abstract void ElementWrite(NetDataWriter w, ref TProperty prop);

			public override void Read(TClass inf, NetDataReader r)
			{
				ElementRead(r, out var prop);
				Setter(inf, prop);
			}

			public override void Write(TClass inf, NetDataWriter w)
			{
				TProperty prop = Getter(inf);
				ElementWrite(w, ref prop);
			}

			public override void ReadArray(TClass inf, NetDataReader r)
			{
				TProperty[] array = ReadArrayHelper(inf, r);
				for (int i = 0; i < array.Length; i++)
				{
					ElementRead(r, out array[i]);
				}
			}

			public override void WriteArray(TClass inf, NetDataWriter w)
			{
				TProperty[] array = WriteArrayHelper(inf, w);
				for (int i = 0; i < array.Length; i++)
				{
					ElementWrite(w, ref array[i]);
				}
			}
		}

		private sealed class FastCallStatic<TClass, TProperty> : FastCallSpecific<TClass, TProperty>
		{
			private readonly Action<NetDataWriter, TProperty> _writer;

			private readonly Func<NetDataReader, TProperty> _reader;

			public FastCallStatic(Action<NetDataWriter, TProperty> write, Func<NetDataReader, TProperty> read)
			{
				_writer = write;
				_reader = read;
			}

			public override void Read(TClass inf, NetDataReader r)
			{
				Setter(inf, _reader(r));
			}

			public override void Write(TClass inf, NetDataWriter w)
			{
				_writer(w, Getter(inf));
			}

			public override void ReadList(TClass inf, NetDataReader r)
			{
				int len;
				List<TProperty> list = ReadListHelper(inf, r, out len);
				int count = list.Count;
				for (int i = 0; i < len; i++)
				{
					if (i < count)
					{
						list[i] = _reader(r);
					}
					else
					{
						list.Add(_reader(r));
					}
				}
				if (len < count)
				{
					list.RemoveRange(len, count - len);
				}
			}

			public override void WriteList(TClass inf, NetDataWriter w)
			{
				int len;
				List<TProperty> list = WriteListHelper(inf, w, out len);
				for (int i = 0; i < len; i++)
				{
					_writer(w, list[i]);
				}
			}

			public override void ReadArray(TClass inf, NetDataReader r)
			{
				TProperty[] array = ReadArrayHelper(inf, r);
				int num = array.Length;
				for (int i = 0; i < num; i++)
				{
					array[i] = _reader(r);
				}
			}

			public override void WriteArray(TClass inf, NetDataWriter w)
			{
				TProperty[] array = WriteArrayHelper(inf, w);
				int num = array.Length;
				for (int i = 0; i < num; i++)
				{
					_writer(w, array[i]);
				}
			}
		}

		private sealed class FastCallStruct<TClass, TProperty> : FastCallSpecific<TClass, TProperty> where TProperty : struct, INetSerializable
		{
			private TProperty _p;

			public override void Read(TClass inf, NetDataReader r)
			{
				_p.Deserialize(r);
				Setter(inf, _p);
			}

			public override void Write(TClass inf, NetDataWriter w)
			{
				_p = Getter(inf);
				_p.Serialize(w);
			}

			public override void ReadList(TClass inf, NetDataReader r)
			{
				int len;
				List<TProperty> list = ReadListHelper(inf, r, out len);
				int count = list.Count;
				for (int i = 0; i < len; i++)
				{
					TProperty val = default(TProperty);
					val.Deserialize(r);
					if (i < count)
					{
						list[i] = val;
					}
					else
					{
						list.Add(val);
					}
				}
				if (len < count)
				{
					list.RemoveRange(len, count - len);
				}
			}

			public override void WriteList(TClass inf, NetDataWriter w)
			{
				int len;
				List<TProperty> list = WriteListHelper(inf, w, out len);
				for (int i = 0; i < len; i++)
				{
					list[i].Serialize(w);
				}
			}

			public override void ReadArray(TClass inf, NetDataReader r)
			{
				TProperty[] array = ReadArrayHelper(inf, r);
				int num = array.Length;
				for (int i = 0; i < num; i++)
				{
					array[i].Deserialize(r);
				}
			}

			public override void WriteArray(TClass inf, NetDataWriter w)
			{
				TProperty[] array = WriteArrayHelper(inf, w);
				int num = array.Length;
				for (int i = 0; i < num; i++)
				{
					array[i].Serialize(w);
				}
			}
		}

		private sealed class FastCallClass<TClass, TProperty> : FastCallSpecific<TClass, TProperty> where TProperty : class, INetSerializable
		{
			private readonly Func<TProperty> _constructor;

			public FastCallClass(Func<TProperty> constructor)
			{
				_constructor = constructor;
			}

			public override void Read(TClass inf, NetDataReader r)
			{
				TProperty val = _constructor();
				val.Deserialize(r);
				Setter(inf, val);
			}

			public override void Write(TClass inf, NetDataWriter w)
			{
				Getter(inf)?.Serialize(w);
			}

			public override void ReadList(TClass inf, NetDataReader r)
			{
				int len;
				List<TProperty> list = ReadListHelper(inf, r, out len);
				int count = list.Count;
				for (int i = 0; i < len; i++)
				{
					if (i < count)
					{
						list[i].Deserialize(r);
						continue;
					}
					TProperty val = _constructor();
					val.Deserialize(r);
					list.Add(val);
				}
				if (len < count)
				{
					list.RemoveRange(len, count - len);
				}
			}

			public override void WriteList(TClass inf, NetDataWriter w)
			{
				int len;
				List<TProperty> list = WriteListHelper(inf, w, out len);
				for (int i = 0; i < len; i++)
				{
					list[i].Serialize(w);
				}
			}

			public override void ReadArray(TClass inf, NetDataReader r)
			{
				TProperty[] array = ReadArrayHelper(inf, r);
				int num = array.Length;
				for (int i = 0; i < num; i++)
				{
					array[i] = _constructor();
					array[i].Deserialize(r);
				}
			}

			public override void WriteArray(TClass inf, NetDataWriter w)
			{
				TProperty[] array = WriteArrayHelper(inf, w);
				int num = array.Length;
				for (int i = 0; i < num; i++)
				{
					array[i].Serialize(w);
				}
			}
		}

		private class IntSerializer<T> : FastCallSpecific<T, int>
		{
			public override void Read(T inf, NetDataReader r)
			{
				Setter(inf, r.GetInt());
			}

			public override void Write(T inf, NetDataWriter w)
			{
				w.Put(Getter(inf));
			}

			public override void ReadArray(T inf, NetDataReader r)
			{
				SetterArr(inf, r.GetIntArray());
			}

			public override void WriteArray(T inf, NetDataWriter w)
			{
				w.PutArray(GetterArr(inf));
			}
		}

		private class UIntSerializer<T> : FastCallSpecific<T, uint>
		{
			public override void Read(T inf, NetDataReader r)
			{
				Setter(inf, r.GetUInt());
			}

			public override void Write(T inf, NetDataWriter w)
			{
				w.Put(Getter(inf));
			}

			public override void ReadArray(T inf, NetDataReader r)
			{
				SetterArr(inf, r.GetUIntArray());
			}

			public override void WriteArray(T inf, NetDataWriter w)
			{
				w.PutArray(GetterArr(inf));
			}
		}

		private class ShortSerializer<T> : FastCallSpecific<T, short>
		{
			public override void Read(T inf, NetDataReader r)
			{
				Setter(inf, r.GetShort());
			}

			public override void Write(T inf, NetDataWriter w)
			{
				w.Put(Getter(inf));
			}

			public override void ReadArray(T inf, NetDataReader r)
			{
				SetterArr(inf, r.GetShortArray());
			}

			public override void WriteArray(T inf, NetDataWriter w)
			{
				w.PutArray(GetterArr(inf));
			}
		}

		private class UShortSerializer<T> : FastCallSpecific<T, ushort>
		{
			public override void Read(T inf, NetDataReader r)
			{
				Setter(inf, r.GetUShort());
			}

			public override void Write(T inf, NetDataWriter w)
			{
				w.Put(Getter(inf));
			}

			public override void ReadArray(T inf, NetDataReader r)
			{
				SetterArr(inf, r.GetUShortArray());
			}

			public override void WriteArray(T inf, NetDataWriter w)
			{
				w.PutArray(GetterArr(inf));
			}
		}

		private class LongSerializer<T> : FastCallSpecific<T, long>
		{
			public override void Read(T inf, NetDataReader r)
			{
				Setter(inf, r.GetLong());
			}

			public override void Write(T inf, NetDataWriter w)
			{
				w.Put(Getter(inf));
			}

			public override void ReadArray(T inf, NetDataReader r)
			{
				SetterArr(inf, r.GetLongArray());
			}

			public override void WriteArray(T inf, NetDataWriter w)
			{
				w.PutArray(GetterArr(inf));
			}
		}

		private class ULongSerializer<T> : FastCallSpecific<T, ulong>
		{
			public override void Read(T inf, NetDataReader r)
			{
				Setter(inf, r.GetULong());
			}

			public override void Write(T inf, NetDataWriter w)
			{
				w.Put(Getter(inf));
			}

			public override void ReadArray(T inf, NetDataReader r)
			{
				SetterArr(inf, r.GetULongArray());
			}

			public override void WriteArray(T inf, NetDataWriter w)
			{
				w.PutArray(GetterArr(inf));
			}
		}

		private class ByteSerializer<T> : FastCallSpecific<T, byte>
		{
			public override void Read(T inf, NetDataReader r)
			{
				Setter(inf, r.GetByte());
			}

			public override void Write(T inf, NetDataWriter w)
			{
				w.Put(Getter(inf));
			}

			public override void ReadArray(T inf, NetDataReader r)
			{
				SetterArr(inf, r.GetBytesWithLength());
			}

			public override void WriteArray(T inf, NetDataWriter w)
			{
				w.PutBytesWithLength(GetterArr(inf));
			}
		}

		private class SByteSerializer<T> : FastCallSpecific<T, sbyte>
		{
			public override void Read(T inf, NetDataReader r)
			{
				Setter(inf, r.GetSByte());
			}

			public override void Write(T inf, NetDataWriter w)
			{
				w.Put(Getter(inf));
			}

			public override void ReadArray(T inf, NetDataReader r)
			{
				SetterArr(inf, r.GetSBytesWithLength());
			}

			public override void WriteArray(T inf, NetDataWriter w)
			{
				w.PutSBytesWithLength(GetterArr(inf));
			}
		}

		private class FloatSerializer<T> : FastCallSpecific<T, float>
		{
			public override void Read(T inf, NetDataReader r)
			{
				Setter(inf, r.GetFloat());
			}

			public override void Write(T inf, NetDataWriter w)
			{
				w.Put(Getter(inf));
			}

			public override void ReadArray(T inf, NetDataReader r)
			{
				SetterArr(inf, r.GetFloatArray());
			}

			public override void WriteArray(T inf, NetDataWriter w)
			{
				w.PutArray(GetterArr(inf));
			}
		}

		private class DoubleSerializer<T> : FastCallSpecific<T, double>
		{
			public override void Read(T inf, NetDataReader r)
			{
				Setter(inf, r.GetDouble());
			}

			public override void Write(T inf, NetDataWriter w)
			{
				w.Put(Getter(inf));
			}

			public override void ReadArray(T inf, NetDataReader r)
			{
				SetterArr(inf, r.GetDoubleArray());
			}

			public override void WriteArray(T inf, NetDataWriter w)
			{
				w.PutArray(GetterArr(inf));
			}
		}

		private class BoolSerializer<T> : FastCallSpecific<T, bool>
		{
			public override void Read(T inf, NetDataReader r)
			{
				Setter(inf, r.GetBool());
			}

			public override void Write(T inf, NetDataWriter w)
			{
				w.Put(Getter(inf));
			}

			public override void ReadArray(T inf, NetDataReader r)
			{
				SetterArr(inf, r.GetBoolArray());
			}

			public override void WriteArray(T inf, NetDataWriter w)
			{
				w.PutArray(GetterArr(inf));
			}
		}

		private class CharSerializer<T> : FastCallSpecificAuto<T, char>
		{
			protected override void ElementWrite(NetDataWriter w, ref char prop)
			{
				w.Put(prop);
			}

			protected override void ElementRead(NetDataReader r, out char prop)
			{
				prop = r.GetChar();
			}
		}

		private class IPEndPointSerializer<T> : FastCallSpecificAuto<T, IPEndPoint>
		{
			protected override void ElementWrite(NetDataWriter w, ref IPEndPoint prop)
			{
				w.Put(prop);
			}

			protected override void ElementRead(NetDataReader r, out IPEndPoint prop)
			{
				prop = r.GetNetEndPoint();
			}
		}

		private class GuidSerializer<T> : FastCallSpecificAuto<T, Guid>
		{
			protected override void ElementWrite(NetDataWriter w, ref Guid guid)
			{
				w.Put(guid);
			}

			protected override void ElementRead(NetDataReader r, out Guid guid)
			{
				guid = r.GetGuid();
			}
		}

		private class StringSerializer<T> : FastCallSpecific<T, string>
		{
			private readonly int _maxLength;

			public StringSerializer(int maxLength)
			{
				_maxLength = ((maxLength > 0) ? maxLength : 32767);
			}

			public override void Read(T inf, NetDataReader r)
			{
				Setter(inf, r.GetString(_maxLength));
			}

			public override void Write(T inf, NetDataWriter w)
			{
				w.Put(Getter(inf), _maxLength);
			}

			public override void ReadArray(T inf, NetDataReader r)
			{
				SetterArr(inf, r.GetStringArray(_maxLength));
			}

			public override void WriteArray(T inf, NetDataWriter w)
			{
				w.PutArray(GetterArr(inf), _maxLength);
			}
		}

		private class EnumByteSerializer<T> : FastCall<T>
		{
			protected readonly PropertyInfo Property;

			protected readonly Type PropertyType;

			public EnumByteSerializer(PropertyInfo property, Type propertyType)
			{
				Property = property;
				PropertyType = propertyType;
			}

			public override void Read(T inf, NetDataReader r)
			{
				Property.SetValue(inf, Enum.ToObject(PropertyType, r.GetByte()), null);
			}

			public override void Write(T inf, NetDataWriter w)
			{
				w.Put((byte)Property.GetValue(inf, null));
			}

			public override void ReadArray(T inf, NetDataReader r)
			{
				throw new InvalidTypeException("Unsupported type: Enum[]");
			}

			public override void WriteArray(T inf, NetDataWriter w)
			{
				throw new InvalidTypeException("Unsupported type: Enum[]");
			}

			public override void ReadList(T inf, NetDataReader r)
			{
				throw new InvalidTypeException("Unsupported type: List<Enum>");
			}

			public override void WriteList(T inf, NetDataWriter w)
			{
				throw new InvalidTypeException("Unsupported type: List<Enum>");
			}
		}

		private class EnumIntSerializer<T> : EnumByteSerializer<T>
		{
			public EnumIntSerializer(PropertyInfo property, Type propertyType)
				: base(property, propertyType)
			{
			}

			public override void Read(T inf, NetDataReader r)
			{
				Property.SetValue(inf, Enum.ToObject(PropertyType, r.GetInt()), null);
			}

			public override void Write(T inf, NetDataWriter w)
			{
				w.Put((int)Property.GetValue(inf, null));
			}
		}

		private sealed class ClassInfo<T>
		{
			public static ClassInfo<T> Instance;

			private readonly FastCall<T>[] _serializers;

			private readonly int _membersCount;

			public ClassInfo(List<FastCall<T>> serializers)
			{
				_membersCount = serializers.Count;
				_serializers = serializers.ToArray();
			}

			public void Write(T obj, NetDataWriter writer)
			{
				for (int i = 0; i < _membersCount; i++)
				{
					FastCall<T> fastCall = _serializers[i];
					if (fastCall.Type == CallType.Basic)
					{
						fastCall.Write(obj, writer);
					}
					else if (fastCall.Type == CallType.Array)
					{
						fastCall.WriteArray(obj, writer);
					}
					else
					{
						fastCall.WriteList(obj, writer);
					}
				}
			}

			public void Read(T obj, NetDataReader reader)
			{
				for (int i = 0; i < _membersCount; i++)
				{
					FastCall<T> fastCall = _serializers[i];
					if (fastCall.Type == CallType.Basic)
					{
						fastCall.Read(obj, reader);
					}
					else if (fastCall.Type == CallType.Array)
					{
						fastCall.ReadArray(obj, reader);
					}
					else
					{
						fastCall.ReadList(obj, reader);
					}
				}
			}
		}

		private abstract class CustomType
		{
			public abstract FastCall<T> Get<T>();
		}

		private sealed class CustomTypeStruct<TProperty> : CustomType where TProperty : struct, INetSerializable
		{
			public override FastCall<T> Get<T>()
			{
				return new FastCallStruct<T, TProperty>();
			}
		}

		private sealed class CustomTypeClass<TProperty> : CustomType where TProperty : class, INetSerializable
		{
			private readonly Func<TProperty> _constructor;

			public CustomTypeClass(Func<TProperty> constructor)
			{
				_constructor = constructor;
			}

			public override FastCall<T> Get<T>()
			{
				return new FastCallClass<T, TProperty>(_constructor);
			}
		}

		private sealed class CustomTypeStatic<TProperty> : CustomType
		{
			private readonly Action<NetDataWriter, TProperty> _writer;

			private readonly Func<NetDataReader, TProperty> _reader;

			public CustomTypeStatic(Action<NetDataWriter, TProperty> writer, Func<NetDataReader, TProperty> reader)
			{
				_writer = writer;
				_reader = reader;
			}

			public override FastCall<T> Get<T>()
			{
				return new FastCallStatic<T, TProperty>(_writer, _reader);
			}
		}

		private NetDataWriter _writer;

		private readonly int _maxStringLength;

		private readonly Dictionary<Type, CustomType> _registeredTypes = new Dictionary<Type, CustomType>();

		public void RegisterNestedType<T>() where T : struct, INetSerializable
		{
			_registeredTypes.Add(typeof(T), new CustomTypeStruct<T>());
		}

		public void RegisterNestedType<T>(Func<T> constructor) where T : class, INetSerializable
		{
			_registeredTypes.Add(typeof(T), new CustomTypeClass<T>(constructor));
		}

		public void RegisterNestedType<T>(Action<NetDataWriter, T> writer, Func<NetDataReader, T> reader)
		{
			_registeredTypes.Add(typeof(T), new CustomTypeStatic<T>(writer, reader));
		}

		public NetSerializer()
			: this(0)
		{
		}

		public NetSerializer(int maxStringLength)
		{
			_maxStringLength = maxStringLength;
		}

		private ClassInfo<T> RegisterInternal<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			if (ClassInfo<T>.Instance != null)
			{
				return ClassInfo<T>.Instance;
			}
			PropertyInfo[] properties = typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetProperty | BindingFlags.SetProperty);
			List<FastCall<T>> list = new List<FastCall<T>>();
			foreach (PropertyInfo propertyInfo in properties)
			{
				Type propertyType = propertyInfo.PropertyType;
				Type type = (propertyType.IsArray ? propertyType.GetElementType() : propertyType);
				CallType type2 = (propertyType.IsArray ? CallType.Array : CallType.Basic);
				if (propertyType.IsGenericType && propertyType.GetGenericTypeDefinition() == typeof(List<>))
				{
					type = propertyType.GetGenericArguments()[0];
					type2 = CallType.List;
				}
				if (Attribute.IsDefined(propertyInfo, typeof(IgnoreDataMemberAttribute)))
				{
					continue;
				}
				MethodInfo getMethod = propertyInfo.GetGetMethod();
				MethodInfo setMethod = propertyInfo.GetSetMethod();
				if (getMethod == null || setMethod == null)
				{
					continue;
				}
				FastCall<T> fastCall = null;
				if (propertyType.IsEnum)
				{
					Type underlyingType = Enum.GetUnderlyingType(propertyType);
					if (underlyingType == typeof(byte))
					{
						fastCall = new EnumByteSerializer<T>(propertyInfo, propertyType);
					}
					else
					{
						if (!(underlyingType == typeof(int)))
						{
							throw new InvalidTypeException("Not supported enum underlying type: " + underlyingType.Name);
						}
						fastCall = new EnumIntSerializer<T>(propertyInfo, propertyType);
					}
				}
				else if (type == typeof(string))
				{
					fastCall = new StringSerializer<T>(_maxStringLength);
				}
				else if (type == typeof(bool))
				{
					fastCall = new BoolSerializer<T>();
				}
				else if (type == typeof(byte))
				{
					fastCall = new ByteSerializer<T>();
				}
				else if (type == typeof(sbyte))
				{
					fastCall = new SByteSerializer<T>();
				}
				else if (type == typeof(short))
				{
					fastCall = new ShortSerializer<T>();
				}
				else if (type == typeof(ushort))
				{
					fastCall = new UShortSerializer<T>();
				}
				else if (type == typeof(int))
				{
					fastCall = new IntSerializer<T>();
				}
				else if (type == typeof(uint))
				{
					fastCall = new UIntSerializer<T>();
				}
				else if (type == typeof(long))
				{
					fastCall = new LongSerializer<T>();
				}
				else if (type == typeof(ulong))
				{
					fastCall = new ULongSerializer<T>();
				}
				else if (type == typeof(float))
				{
					fastCall = new FloatSerializer<T>();
				}
				else if (type == typeof(double))
				{
					fastCall = new DoubleSerializer<T>();
				}
				else if (type == typeof(char))
				{
					fastCall = new CharSerializer<T>();
				}
				else if (type == typeof(IPEndPoint))
				{
					fastCall = new IPEndPointSerializer<T>();
				}
				else if (type == typeof(Guid))
				{
					fastCall = new GuidSerializer<T>();
				}
				else
				{
					_registeredTypes.TryGetValue(type, out var value);
					if (value != null)
					{
						fastCall = value.Get<T>();
					}
				}
				if (fastCall != null)
				{
					fastCall.Init(getMethod, setMethod, type2);
					list.Add(fastCall);
					continue;
				}
				throw new InvalidTypeException("Unknown property type: " + propertyType.FullName);
			}
			ClassInfo<T>.Instance = new ClassInfo<T>(list);
			return ClassInfo<T>.Instance;
		}

		public void Register<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			RegisterInternal<T>();
		}

		public T Deserialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(NetDataReader reader) where T : class, new()
		{
			ClassInfo<T> classInfo = RegisterInternal<T>();
			T val = new T();
			try
			{
				classInfo.Read(val, reader);
				return val;
			}
			catch
			{
				return null;
			}
		}

		public bool Deserialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(NetDataReader reader, T target) where T : class, new()
		{
			ClassInfo<T> classInfo = RegisterInternal<T>();
			try
			{
				classInfo.Read(target, reader);
			}
			catch
			{
				return false;
			}
			return true;
		}

		public void Serialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(NetDataWriter writer, T obj) where T : class, new()
		{
			RegisterInternal<T>().Write(obj, writer);
		}

		public byte[] Serialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T obj) where T : class, new()
		{
			if (_writer == null)
			{
				_writer = new NetDataWriter();
			}
			_writer.Reset();
			Serialize(_writer, obj);
			return _writer.CopyData();
		}
	}
	public class NtpPacket
	{
		private static readonly DateTime Epoch = new DateTime(1900, 1, 1);

		public byte[] Bytes { get; }

		public NtpLeapIndicator LeapIndicator => (NtpLeapIndicator)((Bytes[0] & 0xC0) >> 6);

		public int VersionNumber
		{
			get
			{
				return (Bytes[0] & 0x38) >> 3;
			}
			private set
			{
				Bytes[0] = (byte)((Bytes[0] & 0xFFFFFFC7u) | (uint)(value << 3));
			}
		}

		public NtpMode Mode
		{
			get
			{
				return (NtpMode)(Bytes[0] & 7);
			}
			private set
			{
				Bytes[0] = (byte)((Bytes[0] & 0xFFFFFFF8u) | (uint)value);
			}
		}

		public int Stratum => Bytes[1];

		public int Poll => Bytes[2];

		public int Precision => (sbyte)Bytes[3];

		public TimeSpan RootDelay => GetTimeSpan32(4);

		public TimeSpan RootDispersion => GetTimeSpan32(8);

		public uint ReferenceId => GetUInt32BE(12);

		public DateTime? ReferenceTimestamp => GetDateTime64(16);

		public DateTime? OriginTimestamp => GetDateTime64(24);

		public DateTime? ReceiveTimestamp => GetDateTime64(32);

		public DateTime? TransmitTimestamp
		{
			get
			{
				return GetDateTime64(40);
			}
			private set
			{
				SetDateTime64(40, value);
			}
		}

		public DateTime? DestinationTimestamp { get; private set; }

		public TimeSpan RoundTripTime
		{
			get
			{
				CheckTimestamps();
				return ReceiveTimestamp.Value - OriginTimestamp.Value + (DestinationTimestamp.Value - TransmitTimestamp.Value);
			}
		}

		public TimeSpan CorrectionOffset
		{
			get
			{
				CheckTimestamps();
				return TimeSpan.FromTicks((ReceiveTimestamp.Value - OriginTimestamp.Value - (DestinationTimestamp.Value - TransmitTimestamp.Value)).Ticks / 2);
			}
		}

		public NtpPacket()
			: this(new byte[48])
		{
			Mode = NtpMode.Client;
			VersionNumber = 4;
			TransmitTimestamp = DateTime.UtcNow;
		}

		internal NtpPacket(byte[] bytes)
		{
			if (bytes.Length < 48)
			{
				throw new ArgumentException("SNTP reply packet must be at least 48 bytes long.", "bytes");
			}
			Bytes = bytes;
		}

		public static NtpPacket FromServerResponse(byte[] bytes, DateTime destinationTimestamp)
		{
			return new NtpPacket(bytes)
			{
				DestinationTimestamp = destinationTimestamp
			};
		}

		internal void ValidateRequest()
		{
			if (Mode != NtpMode.Client)
			{
				throw new InvalidOperationException("This is not a request SNTP packet.");
			}
			if (VersionNumber == 0)
			{
				throw new InvalidOperationException("Protocol version of the request is not specified.");
			}
			if (!TransmitTimestamp.HasValue)
			{
				throw new InvalidOperationException("TransmitTimestamp must be set in request packet.");
			}
		}

		internal void ValidateReply()
		{
			if (Mode != NtpMode.Server)
			{
				throw new InvalidOperationException("This is not a reply SNTP packet.");
			}
			if (VersionNumber == 0)
			{
				throw new InvalidOperationException("Protocol version of the reply is not specified.");
			}
			if (Stratum == 0)
			{
				throw new InvalidOperationException($"Received Kiss-o'-Death SNTP packet with code 0x{ReferenceId:x}.");
			}
			if (LeapIndicator == NtpLeapIndicator.AlarmCondition)
			{
				throw new InvalidOperationException("SNTP server has unsynchronized clock.");
			}
			CheckTimestamps();
		}

		private void CheckTimestamps()
		{
			if (!OriginTimestamp.HasValue)
			{
				throw new InvalidOperationException("Origin timestamp is missing.");
			}
			if (!ReceiveTimestamp.HasValue)
			{
				throw new InvalidOperationException("Receive timestamp is missing.");
			}
			if (!TransmitTimestamp.HasValue)
			{
				throw new InvalidOperationException("Transmit timestamp is missing.");
			}
			if (!DestinationTimestamp.HasValue)
			{
				throw new InvalidOperationException("Destination timestamp is missing.");
			}
		}

		private DateTime? GetDateTime64(int offset)
		{
			ulong uInt64BE = GetUInt64BE(offset);
			if (uInt64BE == 0L)
			{
				return null;
			}
			return new DateTime(Epoch.Ticks + Convert.ToInt64((double)uInt64BE * 0.0023283064365386963));
		}

		private void SetDateTime64(int offset, DateTime? value)
		{
			SetUInt64BE(offset, (!value.HasValue) ? 0 : Convert.ToUInt64((double)(value.Value.Ticks - Epoch.Ticks) * 429.4967296));
		}

		private TimeSpan GetTimeSpan32(int offset)
		{
			return TimeSpan.FromSeconds((double)GetInt32BE(offset) / 65536.0);
		}

		private ulong GetUInt64BE(int offset)
		{
			return SwapEndianness(BitConverter.ToUInt64(Bytes, offset));
		}

		private void SetUInt64BE(int offset, ulong value)
		{
			FastBitConverter.GetBytes(Bytes, offset, SwapEndianness(value));
		}

		private int GetInt32BE(int offset)
		{
			return (int)GetUInt32BE(offset);
		}

		private uint GetUInt32BE(int offset)
		{
			return SwapEndianness(BitConverter.ToUInt32(Bytes, offset));
		}

		private static uint SwapEndianness(uint x)
		{
			return ((x & 0xFF) << 24) | ((x & 0xFF00) << 8) | ((x & 0xFF0000) >> 8) | ((x & 0xFF000000u) >> 24);
		}

		private static ulong SwapEndianness(ulong x)
		{
			return ((ulong)SwapEndianness((uint)x) << 32) | SwapEndianness((uint)(x >> 32));
		}
	}
	public enum NtpLeapIndicator
	{
		NoWarning,
		LastMinuteHas61Seconds,
		LastMinuteHas59Seconds,
		AlarmCondition
	}
	public enum NtpMode
	{
		Client = 3,
		Server
	}
	internal sealed class NtpRequest
	{
		private const int ResendTimer = 1000;

		private const int KillTimer = 10000;

		public const int DefaultPort = 123;

		private readonly IPEndPoint _ntpEndPoint;

		private float _resendTime = 1000f;

		private float _killTime;

		public bool NeedToKill => _killTime >= 10000f;

		public NtpRequest(IPEndPoint endPoint)
		{
			_ntpEndPoint = endPoint;
		}

		public bool Send(System.Net.Sockets.Socket socket, float time)
		{
			_resendTime += time;
			_killTime += time;
			if (_resendTime < 1000f)
			{
				return false;
			}
			NtpPacket ntpPacket = new NtpPacket();
			try
			{
				return socket.SendTo(ntpPacket.Bytes, 0, ntpPacket.Bytes.Length, SocketFlags.None, _ntpEndPoint) == ntpPacket.Bytes.Length;
			}
			catch
			{
				return false;
			}
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	public class PreserveAttribute : Attribute
	{
	}
}
namespace LiteNetLib.Layers
{
	public sealed class Crc32cLayer : PacketLayerBase
	{
		public Crc32cLayer()
			: base(4)
		{
		}

		public override void ProcessInboundPacket(ref IPEndPoint endPoint, ref byte[] data, ref int length)
		{
			if (length < 5)
			{
				NetDebug.WriteError("[NM] DataReceived size: bad!");
				length = 0;
				return;
			}
			int num = length - 4;
			if (CRC32C.Compute(data, 0, num) != BitConverter.ToUInt32(data, num))
			{
				length = 0;
			}
			else
			{
				length -= 4;
			}
		}

		public override void ProcessOutBoundPacket(ref IPEndPoint endPoint, ref byte[] data, ref int offset, ref int length)
		{
			FastBitConverter.GetBytes(data, length, CRC32C.Compute(data, offset, length));
			length += 4;
		}
	}
	public abstract class PacketLayerBase
	{
		public readonly int ExtraPacketSizeForLayer;

		protected PacketLayerBase(int extraPacketSizeForLayer)
		{
			ExtraPacketSizeForLayer = extraPacketSizeForLayer;
		}

		public abstract void ProcessInboundPacket(ref IPEndPoint endPoint, ref byte[] data, ref int length);

		public abstract void ProcessOutBoundPacket(ref IPEndPoint endPoint, ref byte[] data, ref int offset, ref int length);
	}
	public class XorEncryptLayer : PacketLayerBase
	{
		private byte[] _byteKey;

		public XorEncryptLayer()
			: base(0)
		{
		}

		public XorEncryptLayer(byte[] key)
			: this()
		{
			SetKey(key);
		}

		public XorEncryptLayer(string key)
			: this()
		{
			SetKey(key);
		}

		public void SetKey(string key)
		{
			_byteKey = Encoding.UTF8.GetBytes(key);
		}

		public void SetKey(byte[] key)
		{
			if (_byteKey == null || _byteKey.Length != key.Length)
			{
				_byteKey = new byte[key.Length];
			}
			Buffer.BlockCopy(key, 0, _byteKey, 0, key.Length);
		}

		public override void ProcessInboundPacket(ref IPEndPoint endPoint, ref byte[] data, ref int length)
		{
			if (_byteKey != null)
			{
				for (int i = 0; i < length; i++)
				{
					data[i] ^= _byteKey[i % _byteKey.Length];
				}
			}
		}

		public override void ProcessOutBoundPacket(ref IPEndPoint endPoint, ref byte[] data, ref int offset, ref int length)
		{
			if (_byteKey != null)
			{
				int num = offset;
				int num2 = 0;
				while (num2 < length)
				{
					data[num] ^= _byteKey[num2 % _byteKey.Length];
					num2++;
					num++;
				}
			}
		}
	}
}
namespace GroovyCodecs.G711.aLaw
{
	public class ALawDecoder
	{
		private static short[] _aLawDecompressTable = new short[256]
		{
			-5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736, -7552, -7296,
			-8064, -7808, -6528, -6272, -7040, -6784, -2752, -2624, -3008, -2880,
			-2240, -2112, -2496, -2368, -3776, -3648, -4032, -3904, -3264, -3136,
			-3520, -3392, -22016, -20992, -24064, -23040, -17920, -16896, -19968, -18944,
			-30208, -29184, -32256, -31232, -26112, -25088, -28160, -27136, -11008, -10496,
			-12032, -11520, -8960, -8448, -9984, -9472, -15104, -14592, -16128, -15616,
			-13056, -12544, -14080, -13568, -344, -328, -376, -360, -280, -264,
			-312, -296, -472, -456, -504, -488, -408, -392, -440, -424,
			-88, -72, -120, -104, -24, -8, -56, -40, -216, -200,
			-248, -232, -152, -136, -184, -168, -1376, -1312, -1504, -1440,
			-1120, -1056, -1248, -1184, -1888, -1824, -2016, -1952, -1632, -1568,
			-1760, -1696, -688, -656, -752, -720, -560, -528, -624, -592,
			-944, -912, -1008, -976, -816, -784, -880, -848, 5504, 5248,
			6016, 5760, 4480, 4224, 4992, 4736, 7552, 7296, 8064, 7808,
			6528, 6272, 7040, 6784, 2752, 2624, 3008, 2880, 2240, 2112,
			2496, 2368, 3776, 3648, 4032, 3904, 3264, 3136, 3520, 3392,
			22016, 20992, 24064, 23040, 17920, 16896, 19968, 18944, 30208, 29184,
			32256, 31232, 26112, 25088, 28160, 27136, 11008, 10496, 12032, 11520,
			8960, 8448, 9984, 9472, 15104, 14592, 16128, 15616, 13056, 12544,
			14080, 13568, 344, 328, 376, 360, 280, 264, 312, 296,
			472, 456, 504, 488, 408, 392, 440, 424, 88, 72,
			120, 104, 24, 8, 56, 40, 216, 200, 248, 232,
			152, 136, 184, 168, 1376, 1312, 1504, 1440, 1120, 1056,
			1248, 1184, 1888, 1824, 2016, 1952, 1632, 1568, 1760, 1696,
			688, 656, 752, 720, 560, 528, 624, 592, 944, 912,
			1008, 976, 816, 784, 880, 848
		};

		public short[] Process(byte[] frame)
		{
			int num = frame.Length;
			short[] array = new short[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = _aLawDecompressTable[frame[i] & 0xFF];
			}
			return array;
		}
	}
	public class ALawEncoder
	{
		private EncoderData _encoderData = new EncoderData();

		public byte[] Process(short[] data)
		{
			int num = data.Length;
			byte[] array = new byte[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = _encoderData.ALawCompressTable[data[i] & 0xFFFF];
			}
			return array;
		}
	}
	internal class EncoderData
	{
		private static byte[][] _aLawCompressTableChunks = new byte[256][];

		private static byte[] _aLawCompressTable = new byte[65536];

		private bool _initialized;

		private readonly object _lock = new object();

		public byte[] ALawCompressTable => _aLawCompressTable;

		public EncoderData()
		{
			if (_initialized)
			{
				return;
			}
			lock (_lock)
			{
				if (!_initialized)
				{
					_initialized = true;
					init0_31();
					init32_63();
					init64_95();
					init96_127();
					init128_159();
					init160_191();
					init192_223();
					init224_255();
					for (int i = 0; i < 256; i++)
					{
						Array.Copy(_aLawCompressTableChunks[i], 0, _aLawCompressTable, i * 256, 256);
					}
				}
			}
		}

		private static void init0_31()
		{
			_aLawCompressTableChunks[0] = new byte[256]
			{
				213, 213, 213, 213, 213, 213, 213, 213, 213, 213,
				213, 213, 213, 213, 213, 213, 212, 212, 212, 212,
				212, 212, 212, 212, 212, 212, 212, 212, 212, 212,
				212, 212, 215, 215, 215, 215, 215, 215, 215, 215,
				215, 215, 215, 215, 215, 215, 215, 215, 214, 214,
				214, 214, 214, 214, 214, 214, 214, 214, 214, 214,
				214, 214, 214, 214, 209, 209, 209, 209, 209, 209,
				209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
				208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
				208, 208, 208, 208, 208, 208, 211, 211, 211, 211,
				211, 211, 211, 211, 211, 211, 211, 211, 211, 211,
				211, 211, 210, 210, 210, 210, 210, 210, 210, 210,
				210, 210, 210, 210, 210, 210, 210, 210, 221, 221,
				221, 221, 221, 221, 221, 221, 221, 221, 221, 221,
				221, 221, 221, 221, 220, 220, 220, 220, 220, 220,
				220, 220, 220, 220, 220, 220, 220, 220, 220, 220,
				223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
				223, 223, 223, 223, 223, 223, 222, 222, 222, 222,
				222, 222, 222, 222, 222, 222, 222, 222, 222, 222,
				222, 222, 217, 217, 217, 217, 217, 217, 217, 217,
				217, 217, 217, 217, 217, 217, 217, 217, 216, 216,
				216, 216, 216, 216, 216, 216, 216, 216, 216, 216,
				216, 216, 216, 216, 219, 219, 219, 219, 219, 219,
				219, 219, 219, 219, 219, 219, 219, 219, 219, 219,
				218, 218, 218, 218, 218, 218, 218, 218, 218, 218,
				218, 218, 218, 218, 218, 218
			};
			_aLawCompressTableChunks[1] = new byte[256]
			{
				197, 197, 197, 197, 197, 197, 197, 197, 197, 197,
				197, 197, 197, 197, 197, 197, 196, 196, 196, 196,
				196, 196, 196, 196, 196, 196, 196, 196, 196, 196,
				196, 196, 199, 199, 199, 199, 199, 199, 199, 199,
				199, 199, 199, 199, 199, 199, 199, 199, 198, 198,
				198, 198, 198, 198, 198, 198, 198, 198, 198, 198,
				198, 198, 198, 198, 193, 193, 193, 193, 193, 193,
				193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
				192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
				192, 192, 192, 192, 192, 192, 195, 195, 195, 195,
				195, 195, 195, 195, 195, 195, 195, 195, 195, 195,
				195, 195, 194, 194, 194, 194, 194, 194, 194, 194,
				194, 194, 194, 194, 194, 194, 194, 194, 205, 205,
				205, 205, 205, 205, 205, 205, 205, 205, 205, 205,
				205, 205, 205, 205, 204, 204, 204, 204, 204, 204,
				204, 204, 204, 204, 204, 204, 204, 204, 204, 204,
				207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
				207, 207, 207, 207, 207, 207, 206, 206, 206, 206,
				206, 206, 206, 206, 206, 206, 206, 206, 206, 206,
				206, 206, 201, 201, 201, 201, 201, 201, 201, 201,
				201, 201, 201, 201, 201, 201, 201, 201, 200, 200,
				200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
				200, 200, 200, 200, 203, 203, 203, 203, 203, 203,
				203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
				202, 202, 202, 202, 202, 202, 202, 202, 202, 202,
				202, 202, 202, 202, 202, 202
			};
			_aLawCompressTableChunks[2] = new byte[256]
			{
				245, 245, 245, 245, 245, 245, 245, 245, 245, 245,
				245, 245, 245, 245, 245, 245, 245, 245, 245, 245,
				245, 245, 245, 245, 245, 245, 245, 245, 245, 245,
				245, 245, 244, 244, 244, 244, 244, 244, 244, 244,
				244, 244, 244, 244, 244, 244, 244, 244, 244, 244,
				244, 244, 244, 244, 244, 244, 244, 244, 244, 244,
				244, 244, 244, 244, 247, 247, 247, 247, 247, 247,
				247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
				247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
				247, 247, 247, 247, 247, 247, 246, 246, 246, 246,
				246, 246, 246, 246, 246, 246, 246, 246, 246, 246,
				246, 246, 246, 246, 246, 246, 246, 246, 246, 246,
				246, 246, 246, 246, 246, 246, 246, 246, 241, 241,
				241, 241, 241, 241, 241, 241, 241, 241, 241, 241,
				241, 241, 241, 241, 241, 241, 241, 241, 241, 241,
				241, 241, 241, 241, 241, 241, 241, 241, 241, 241,
				240, 240, 240, 240, 240, 240, 240, 240, 240, 240,
				240, 240, 240, 240, 240, 240, 240, 240, 240, 240,
				240, 240, 240, 240, 240, 240, 240, 240, 240, 240,
				240, 240, 243, 243, 243, 243, 243, 243, 243, 243,
				243, 243, 243, 243, 243, 243, 243, 243, 243, 243,
				243, 243, 243, 243, 243, 243, 243, 243, 243, 243,
				243, 243, 243, 243, 242, 242, 242, 242, 242, 242,
				242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
				242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
				242, 242, 242, 242, 242, 242
			};
			_aLawCompressTableChunks[3] = new byte[256]
			{
				253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
				253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
				253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
				253, 253, 252, 252, 252, 252, 252, 252, 252, 252,
				252, 252, 252, 252, 252, 252, 252, 252, 252, 252,
				252, 252, 252, 252, 252, 252, 252, 252, 252, 252,
				252, 252, 252, 252, 255, 255, 255, 255, 255, 255,
				255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
				255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
				255, 255, 255, 255, 255, 255, 254, 254, 254, 254,
				254, 254, 254, 254, 254, 254, 254, 254, 254, 254,
				254, 254, 254, 254, 254, 254, 254, 254, 254, 254,
				254, 254, 254, 254, 254, 254, 254, 254, 249, 249,
				249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
				249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
				249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
				248, 248, 248, 248, 248, 248, 248, 248, 248, 248,
				248, 248, 248, 248, 248, 248, 248, 248, 248, 248,
				248, 248, 248, 248, 248, 248, 248, 248, 248, 248,
				248, 248, 251, 251, 251, 251, 251, 251, 251, 251,
				251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
				251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
				251, 251, 251, 251, 250, 250, 250, 250, 250, 250,
				250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
				250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
				250, 250, 250, 250, 250, 250
			};
			_aLawCompressTableChunks[4] = new byte[256]
			{
				229, 229, 229, 229, 229, 229, 229, 229, 229, 229,
				229, 229, 229, 229, 229, 229, 229, 229, 229, 229,
				229, 229, 229, 229, 229, 229, 229, 229, 229, 229,
				229, 229, 229, 229, 229, 229, 229, 229, 229, 229,
				229, 229, 229, 229, 229, 229, 229, 229, 229, 229,
				229, 229, 229, 229, 229, 229, 229, 229, 229, 229,
				229, 229, 229, 229, 228, 228, 228, 228, 228, 228,
				228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
				228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
				228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
				228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
				228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
				228, 228, 228, 228, 228, 228, 228, 228, 231, 231,
				231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
				231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
				231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
				231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
				231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
				231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
				231, 231, 230, 230, 230, 230, 230, 230, 230, 230,
				230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
				230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
				230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
				230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
				230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
				230, 230, 230, 230, 230, 230
			};
			_aLawCompressTableChunks[5] = new byte[256]
			{
				225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
				225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
				225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
				225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
				225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
				225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
				225, 225, 225, 225, 224, 224, 224, 224, 224, 224,
				224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
				224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
				224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
				224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
				224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
				224, 224, 224, 224, 224, 224, 224, 224, 227, 227,
				227, 227, 227, 227, 227, 227, 227, 227, 227, 227,
				227, 227, 227, 227, 227, 227, 227, 227, 227, 227,
				227, 227, 227, 227, 227, 227, 227, 227, 227, 227,
				227, 227, 227, 227, 227, 227, 227, 227, 227, 227,
				227, 227, 227, 227, 227, 227, 227, 227, 227, 227,
				227, 227, 227, 227, 227, 227, 227, 227, 227, 227,
				227, 227, 226, 226, 226, 226, 226, 226, 226, 226,
				226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
				226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
				226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
				226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
				226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
				226, 226, 226, 226, 226, 226
			};
			_aLawCompressTableChunks[6] = new byte[256]
			{
				237, 237, 237, 237, 237, 237, 237, 237, 237, 237,
				237, 237, 237, 237, 237, 237, 237, 237, 237, 237,
				237, 237, 237, 237, 237, 237, 237, 237, 237, 237,
				237, 237, 237, 237, 237, 237, 237, 237, 237, 237,
				237, 237, 237, 237, 237, 237, 237, 237, 237, 237,
				237, 237, 237, 237, 237, 237, 237, 237, 237, 237,
				237, 237, 237, 237, 236, 236, 236, 236, 236, 236,
				236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
				236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
				236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
				236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
				236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
				236, 236, 236, 236, 236, 236, 236, 236, 239, 239,
				239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
				239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
				239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
				239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
				239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
				239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
				239, 239, 238, 238, 238, 238, 238, 238, 238, 238,
				238, 238, 238, 238, 238, 238, 238, 238, 238, 238,
				238, 238, 238, 238, 238, 238, 238, 238, 238, 238,
				238, 238, 238, 238, 238, 238, 238, 238, 238, 238,
				238, 238, 238, 238, 238, 238, 238, 238, 238, 238,
				238, 238, 238, 238, 238, 238, 238, 238, 238, 238,
				238, 238, 238, 238, 238, 238
			};
			_aLawCompressTableChunks[7] = new byte[256]
			{
				233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
				233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
				233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
				233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
				233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
				233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
				233, 233, 233, 233, 232, 232, 232, 232, 232, 232,
				232, 232, 232, 232, 232, 232, 232, 232, 232, 232,
				232, 232, 232, 232, 232, 232, 232, 232, 232, 232,
				232, 232, 232, 232, 232, 232, 232, 232, 232, 232,
				232, 232, 232, 232, 232, 232, 232, 232, 232, 232,
				232, 232, 232, 232, 232, 232, 232, 232, 232, 232,
				232, 232, 232, 232, 232, 232, 232, 232, 235, 235,
				235, 235, 235, 235, 235, 235, 235, 235, 235, 235,
				235, 235, 235, 235, 235, 235, 235, 235, 235, 235,
				235, 235, 235, 235, 235, 235, 235, 235, 235, 235,
				235, 235, 235, 235, 235, 235, 235, 235, 235, 235,
				235, 235, 235, 235, 235, 235, 235, 235, 235, 235,
				235, 235, 235, 235, 235, 235, 235, 235, 235, 235,
				235, 235, 234, 234, 234, 234, 234, 234, 234, 234,
				234, 234, 234, 234, 234, 234, 234, 234, 234, 234,
				234, 234, 234, 234, 234, 234, 234, 234, 234, 234,
				234, 234, 234, 234, 234, 234, 234, 234, 234, 234,
				234, 234, 234, 234, 234, 234, 234, 234, 234, 234,
				234, 234, 234, 234, 234, 234, 234, 234, 234, 234,
				234, 234, 234, 234, 234, 234
			};
			_aLawCompressTableChunks[8] = new byte[256]
			{
				149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
				149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
				149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
				149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
				149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
				149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
				149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
				149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
				149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
				149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
				149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
				149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
				149, 149, 149, 149, 149, 149, 149, 149, 148, 148,
				148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
				148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
				148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
				148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
				148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
				148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
				148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
				148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
				148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
				148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
				148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
				148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
				148, 148, 148, 148, 148, 148
			};
			_aLawCompressTableChunks[9] = new byte[256]
			{
				151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
				151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
				151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
				151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
				151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
				151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
				151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
				151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
				151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
				151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
				151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
				151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
				151, 151, 151, 151, 151, 151, 151, 151, 150, 150,
				150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
				150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
				150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
				150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
				150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
				150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
				150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
				150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
				150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
				150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
				150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
				150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
				150, 150, 150, 150, 150, 150
			};
			_aLawCompressTableChunks[10] = new byte[256]
			{
				145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
				145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
				145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
				145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
				145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
				145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
				145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
				145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
				145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
				145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
				145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
				145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
				145, 145, 145, 145, 145, 145, 145, 145, 144, 144,
				144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
				144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
				144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
				144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
				144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
				144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
				144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
				144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
				144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
				144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
				144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
				144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
				144, 144, 144, 144, 144, 144
			};
			_aLawCompressTableChunks[11] = new byte[256]
			{
				147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
				147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
				147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
				147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
				147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
				147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
				147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
				147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
				147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
				147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
				147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
				147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
				147, 147, 147, 147, 147, 147, 147, 147, 146, 146,
				146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
				146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
				146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
				146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
				146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
				146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
				146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
				146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
				146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
				146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
				146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
				146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
				146, 146, 146, 146, 146, 146
			};
			_aLawCompressTableChunks[12] = new byte[256]
			{
				157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
				157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
				157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
				157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
				157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
				157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
				157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
				157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
				157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
				157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
				157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
				157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
				157, 157, 157, 157, 157, 157, 157, 157, 156, 156,
				156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
				156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
				156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
				156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
				156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
				156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
				156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
				156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
				156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
				156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
				156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
				156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
				156, 156, 156, 156, 156, 156
			};
			_aLawCompressTableChunks[13] = new byte[256]
			{
				159, 159, 159, 159, 159, 159, 159, 159, 159, 159,
				159, 159, 159, 159, 159, 159, 159, 159, 159, 159,
				159, 159, 159, 159, 159, 159, 159, 159, 159, 159,
				159, 159, 159, 159, 159, 159, 159, 159, 159, 159,
				159, 159, 159, 159, 159, 159, 159, 159, 159, 159,
				159, 159, 159, 159, 159, 159, 159, 159, 159, 159,
				159, 159, 159, 159, 159, 159, 159, 159, 159, 159,
				159, 159, 159, 159, 159, 159, 159, 159, 159, 159,
				159, 159, 159, 159, 159, 159, 159, 159, 159, 159,
				159, 159, 159, 159, 159, 159, 159, 159, 159, 159,
				159, 159, 159, 159, 159, 159, 159, 159, 159, 159,
				159, 159, 159, 159, 159, 159, 159, 159, 159, 159,
				159, 159, 159, 159, 159, 159, 159, 159, 158, 158,
				158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
				158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
				158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
				158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
				158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
				158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
				158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
				158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
				158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
				158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
				158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
				158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
				158, 158, 158, 158, 158, 158
			};
			_aLawCompressTableChunks[14] = new byte[256]
			{
				153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
				153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
				153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
				153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
				153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
				153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
				153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
				153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
				153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
				153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
				153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
				153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
				153, 153, 153, 153, 153, 153, 153, 153, 152, 152,
				152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
				152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
				152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
				152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
				152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
				152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
				152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
				152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
				152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
				152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
				152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
				152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
				152, 152, 152, 152, 152, 152
			};
			_aLawCompressTableChunks[15] = new byte[256]
			{
				155, 155, 155, 155, 155, 155, 155, 155, 155, 155,
				155, 155, 155, 155, 155, 155, 155, 155, 155, 155,
				155, 155, 155, 155, 155, 155, 155, 155, 155, 155,
				155, 155, 155, 155, 155, 155, 155, 155, 155, 155,
				155, 155, 155, 155, 155, 155, 155, 155, 155, 155,
				155, 155, 155, 155, 155, 155, 155, 155, 155, 155,
				155, 155, 155, 155, 155, 155, 155, 155, 155, 155,
				155, 155, 155, 155, 155, 155, 155, 155, 155, 155,
				155, 155, 155, 155, 155, 155, 155, 155, 155, 155,
				155, 155, 155, 155, 155, 155, 155, 155, 155, 155,
				155, 155, 155, 155, 155, 155, 155, 155, 155, 155,
				155, 155, 155, 155, 155, 155, 155, 155, 155, 155,
				155, 155, 155, 155, 155, 155, 155, 155, 154, 154,
				154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
				154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
				154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
				154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
				154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
				154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
				154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
				154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
				154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
				154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
				154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
				154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
				154, 154, 154, 154, 154, 154
			};
			_aLawCompressTableChunks[16] = new byte[256]
			{
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
				133, 133, 133, 133, 133, 133
			};
			_aLawCompressTableChunks[17] = new byte[256]
			{
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
				132, 132, 132, 132, 132, 132
			};
			_aLawCompressTableChunks[18] = new byte[256]
			{
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
				135, 135, 135, 135, 135, 135
			};
			_aLawCompressTableChunks[19] = new byte[256]
			{
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
				134, 134, 134, 134, 134, 134
			};
			_aLawCompressTableChunks[20] = new byte[256]
			{
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
				129, 129, 129, 129, 129, 129
			};
			_aLawCompressTableChunks[21] = new byte[256]
			{
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
				128, 128, 128, 128, 128, 128
			};
			_aLawCompressTableChunks[22] = new byte[256]
			{
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
				131, 131, 131, 131, 131, 131
			};
			_aLawCompressTableChunks[23] = new byte[256]
			{
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
				130, 130, 130, 130, 130, 130
			};
			_aLawCompressTableChunks[24] = new byte[256]
			{
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
				141, 141, 141, 141, 141, 141
			};
			_aLawCompressTableChunks[25] = new byte[256]
			{
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
				140, 140, 140, 140, 140, 140
			};
			_aLawCompressTableChunks[26] = new byte[256]
			{
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
				143, 143, 143, 143, 143, 143
			};
			_aLawCompressTableChunks[27] = new byte[256]
			{
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
				142, 142, 142, 142, 142, 142
			};
			_aLawCompressTableChunks[28] = new byte[256]
			{
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
				137, 137, 137, 137, 137, 137
			};
			_aLawCompressTableChunks[29] = new byte[256]
			{
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
				136, 136, 136, 136, 136, 136
			};
			_aLawCompressTableChunks[30] = new byte[256]
			{
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
				139, 139, 139, 139, 139, 139
			};
			_aLawCompressTableChunks[31] = new byte[256]
			{
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
				138, 138, 138, 138, 138, 138
			};
		}

		private static void init32_63()
		{
			_aLawCompressTableChunks[32] = new byte[256]
			{
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181
			};
			_aLawCompressTableChunks[33] = new byte[256]
			{
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
				181, 181, 181, 181, 181, 181
			};
			_aLawCompressTableChunks[34] = new byte[256]
			{
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180
			};
			_aLawCompressTableChunks[35] = new byte[256]
			{
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
				180, 180, 180, 180, 180, 180
			};
			_aLawCompressTableChunks[36] = new byte[256]
			{
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183
			};
			_aLawCompressTableChunks[37] = new byte[256]
			{
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
				183, 183, 183, 183, 183, 183
			};
			_aLawCompressTableChunks[38] = new byte[256]
			{
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182
			};
			_aLawCompressTableChunks[39] = new byte[256]
			{
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
				182, 182, 182, 182, 182, 182
			};
			_aLawCompressTableChunks[40] = new byte[256]
			{
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177
			};
			_aLawCompressTableChunks[41] = new byte[256]
			{
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177, 177, 177, 177, 177,
				177, 177, 177, 177, 177, 177
			};
			_aLawCompressTableChunks[42] = new byte[256]
			{
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176
			};
			_aLawCompressTableChunks[43] = new byte[256]
			{
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
				176, 176, 176, 176, 176, 176
			};
			_aLawCompressTableChunks[44] = new byte[256]
			{
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179
			};
			_aLawCompressTableChunks[45] = new byte[256]
			{
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
				179, 179, 179, 179, 179, 179
			};
			_aLawCompressTableChunks[46] = new byte[256]
			{
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178
			};
			_aLawCompressTableChunks[47] = new byte[256]
			{
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
				178, 178, 178, 178, 178, 178
			};
			_aLawCompressTableChunks[48] = new byte[256]
			{
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189
			};
			_aLawCompressTableChunks[49] = new byte[256]
			{
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
				189, 189, 189, 189, 189, 189
			};
			_aLawCompressTableChunks[50] = new byte[256]
			{
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188
			};
			_aLawCompressTableChunks[51] = new byte[256]
			{
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
				188, 188, 188, 188, 188, 188
			};
			_aLawCompressTableChunks[52] = new byte[256]
			{
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191
			};
			_aLawCompressTableChunks[53] = new byte[256]
			{
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
				191, 191, 191, 191, 191, 191
			};
			_aLawCompressTableChunks[54] = new byte[256]
			{
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190
			};
			_aLawCompressTableChunks[55] = new byte[256]
			{
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
				190, 190, 190, 190, 190, 190
			};
			_aLawCompressTableChunks[56] = new byte[256]
			{
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185
			};
			_aLawCompressTableChunks[57] = new byte[256]
			{
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
				185, 185, 185, 185, 185, 185
			};
			_aLawCompressTableChunks[58] = new byte[256]
			{
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184
			};
			_aLawCompressTableChunks[59] = new byte[256]
			{
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
				184, 184, 184, 184, 184, 184
			};
			_aLawCompressTableChunks[60] = new byte[256]
			{
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187
			};
			_aLawCompressTableChunks[61] = new byte[256]
			{
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
				187, 187, 187, 187, 187, 187
			};
			_aLawCompressTableChunks[62] = new byte[256]
			{
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186
			};
			_aLawCompressTableChunks[63] = new byte[256]
			{
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
				186, 186, 186, 186, 186, 186
			};
		}

		private static void init64_95()
		{
			_aLawCompressTableChunks[64] = new byte[256]
			{
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165
			};
			_aLawCompressTableChunks[65] = new byte[256]
			{
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165
			};
			_aLawCompressTableChunks[66] = new byte[256]
			{
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165
			};
			_aLawCompressTableChunks[67] = new byte[256]
			{
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165, 165, 165, 165, 165,
				165, 165, 165, 165, 165, 165
			};
			_aLawCompressTableChunks[68] = new byte[256]
			{
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164
			};
			_aLawCompressTableChunks[69] = new byte[256]
			{
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164
			};
			_aLawCompressTableChunks[70] = new byte[256]
			{
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164
			};
			_aLawCompressTableChunks[71] = new byte[256]
			{
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
				164, 164, 164, 164, 164, 164
			};
			_aLawCompressTableChunks[72] = new byte[256]
			{
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167
			};
			_aLawCompressTableChunks[73] = new byte[256]
			{
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167
			};
			_aLawCompressTableChunks[74] = new byte[256]
			{
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167
			};
			_aLawCompressTableChunks[75] = new byte[256]
			{
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
				167, 167, 167, 167, 167, 167
			};
			_aLawCompressTableChunks[76] = new byte[256]
			{
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166
			};
			_aLawCompressTableChunks[77] = new byte[256]
			{
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166
			};
			_aLawCompressTableChunks[78] = new byte[256]
			{
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166
			};
			_aLawCompressTableChunks[79] = new byte[256]
			{
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166, 166, 166, 166, 166,
				166, 166, 166, 166, 166, 166
			};
			_aLawCompressTableChunks[80] = new byte[256]
			{
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161
			};
			_aLawCompressTableChunks[81] = new byte[256]
			{
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161
			};
			_aLawCompressTableChunks[82] = new byte[256]
			{
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161
			};
			_aLawCompressTableChunks[83] = new byte[256]
			{
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
				161, 161, 161, 161, 161, 161
			};
			_aLawCompressTableChunks[84] = new byte[256]
			{
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160
			};
			_aLawCompressTableChunks[85] = new byte[256]
			{
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160
			};
			_aLawCompressTableChunks[86] = new byte[256]
			{
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160
			};
			_aLawCompressTableChunks[87] = new byte[256]
			{
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
				160, 160, 160, 160, 160, 160
			};
			_aLawCompressTableChunks[88] = new byte[256]
			{
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163
			};
			_aLawCompressTableChunks[89] = new byte[256]
			{
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163
			};
			_aLawCompressTableChunks[90] = new byte[256]
			{
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163
			};
			_aLawCompressTableChunks[91] = new byte[256]
			{
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
				163, 163, 163, 163, 163, 163
			};
			_aLawCompressTableChunks[92] = new byte[256]
			{
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162
			};
			_aLawCompressTableChunks[93] = new byte[256]
			{
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162
			};
			_aLawCompressTableChunks[94] = new byte[256]
			{
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162
			};
			_aLawCompressTableChunks[95] = new byte[256]
			{
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
				162, 162, 162, 162, 162, 162
			};
		}

		private static void init96_127()
		{
			_aLawCompressTableChunks[96] = new byte[256]
			{
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173
			};
			_aLawCompressTableChunks[97] = new byte[256]
			{
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173
			};
			_aLawCompressTableChunks[98] = new byte[256]
			{
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173
			};
			_aLawCompressTableChunks[99] = new byte[256]
			{
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
				173, 173, 173, 173, 173, 173
			};
			_aLawCompressTableChunks[100] = new byte[256]
			{
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172
			};
			_aLawCompressTableChunks[101] = new byte[256]
			{
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172
			};
			_aLawCompressTableChunks[102] = new byte[256]
			{
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172
			};
			_aLawCompressTableChunks[103] = new byte[256]
			{
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
				172, 172, 172, 172, 172, 172
			};
			_aLawCompressTableChunks[104] = new byte[256]
			{
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175
			};
			_aLawCompressTableChunks[105] = new byte[256]
			{
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175
			};
			_aLawCompressTableChunks[106] = new byte[256]
			{
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175
			};
			_aLawCompressTableChunks[107] = new byte[256]
			{
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
				175, 175, 175, 175, 175, 175
			};
			_aLawCompressTableChunks[108] = new byte[256]
			{
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174
			};
			_aLawCompressTableChunks[109] = new byte[256]
			{
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174
			};
			_aLawCompressTableChunks[110] = new byte[256]
			{
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174
			};
			_aLawCompressTableChunks[111] = new byte[256]
			{
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
				174, 174, 174, 174, 174, 174
			};
			_aLawCompressTableChunks[112] = new byte[256]
			{
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169
			};
			_aLawCompressTableChunks[113] = new byte[256]
			{
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169
			};
			_aLawCompressTableChunks[114] = new byte[256]
			{
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169
			};
			_aLawCompressTableChunks[115] = new byte[256]
			{
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
				169, 169, 169, 169, 169, 169
			};
			_aLawCompressTableChunks[116] = new byte[256]
			{
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168
			};
			_aLawCompressTableChunks[117] = new byte[256]
			{
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168
			};
			_aLawCompressTableChunks[118] = new byte[256]
			{
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168
			};
			_aLawCompressTableChunks[119] = new byte[256]
			{
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168, 168, 168, 168, 168,
				168, 168, 168, 168, 168, 168
			};
			_aLawCompressTableChunks[120] = new byte[256]
			{
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171
			};
			_aLawCompressTableChunks[121] = new byte[256]
			{
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171
			};
			_aLawCompressTableChunks[122] = new byte[256]
			{
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171
			};
			_aLawCompressTableChunks[123] = new byte[256]
			{
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
				171, 171, 171, 171, 171, 171
			};
			_aLawCompressTableChunks[124] = new byte[256]
			{
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170
			};
			_aLawCompressTableChunks[125] = new byte[256]
			{
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170
			};
			_aLawCompressTableChunks[126] = new byte[256]
			{
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170
			};
			_aLawCompressTableChunks[127] = new byte[256]
			{
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
				170, 170, 170, 170, 170, 170
			};
		}

		private static void init128_159()
		{
			_aLawCompressTableChunks[128] = new byte[256]
			{
				85, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42
			};
			_aLawCompressTableChunks[129] = new byte[256]
			{
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42
			};
			_aLawCompressTableChunks[130] = new byte[256]
			{
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42
			};
			_aLawCompressTableChunks[131] = new byte[256]
			{
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
				42, 42, 42, 42, 42, 42
			};
			_aLawCompressTableChunks[132] = new byte[256]
			{
				42, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43
			};
			_aLawCompressTableChunks[133] = new byte[256]
			{
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43
			};
			_aLawCompressTableChunks[134] = new byte[256]
			{
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43
			};
			_aLawCompressTableChunks[135] = new byte[256]
			{
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
				43, 43, 43, 43, 43, 43
			};
			_aLawCompressTableChunks[136] = new byte[256]
			{
				43, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40
			};
			_aLawCompressTableChunks[137] = new byte[256]
			{
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40
			};
			_aLawCompressTableChunks[138] = new byte[256]
			{
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40
			};
			_aLawCompressTableChunks[139] = new byte[256]
			{
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
				40, 40, 40, 40, 40, 40
			};
			_aLawCompressTableChunks[140] = new byte[256]
			{
				40, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41
			};
			_aLawCompressTableChunks[141] = new byte[256]
			{
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41
			};
			_aLawCompressTableChunks[142] = new byte[256]
			{
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41
			};
			_aLawCompressTableChunks[143] = new byte[256]
			{
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
				41, 41, 41, 41, 41, 41
			};
			_aLawCompressTableChunks[144] = new byte[256]
			{
				41, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46
			};
			_aLawCompressTableChunks[145] = new byte[256]
			{
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46
			};
			_aLawCompressTableChunks[146] = new byte[256]
			{
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46
			};
			_aLawCompressTableChunks[147] = new byte[256]
			{
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
				46, 46, 46, 46, 46, 46
			};
			_aLawCompressTableChunks[148] = new byte[256]
			{
				46, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47
			};
			_aLawCompressTableChunks[149] = new byte[256]
			{
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47
			};
			_aLawCompressTableChunks[150] = new byte[256]
			{
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47
			};
			_aLawCompressTableChunks[151] = new byte[256]
			{
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
				47, 47, 47, 47, 47, 47
			};
			_aLawCompressTableChunks[152] = new byte[256]
			{
				47, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44
			};
			_aLawCompressTableChunks[153] = new byte[256]
			{
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44
			};
			_aLawCompressTableChunks[154] = new byte[256]
			{
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44
			};
			_aLawCompressTableChunks[155] = new byte[256]
			{
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
				44, 44, 44, 44, 44, 44
			};
			_aLawCompressTableChunks[156] = new byte[256]
			{
				44, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45
			};
			_aLawCompressTableChunks[157] = new byte[256]
			{
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45
			};
			_aLawCompressTableChunks[158] = new byte[256]
			{
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45
			};
			_aLawCompressTableChunks[159] = new byte[256]
			{
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
				45, 45, 45, 45, 45, 45
			};
		}

		private static void init160_191()
		{
			_aLawCompressTableChunks[160] = new byte[256]
			{
				45, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34
			};
			_aLawCompressTableChunks[161] = new byte[256]
			{
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34
			};
			_aLawCompressTableChunks[162] = new byte[256]
			{
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34
			};
			_aLawCompressTableChunks[163] = new byte[256]
			{
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
				34, 34, 34, 34, 34, 34
			};
			_aLawCompressTableChunks[164] = new byte[256]
			{
				34, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35
			};
			_aLawCompressTableChunks[165] = new byte[256]
			{
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35
			};
			_aLawCompressTableChunks[166] = new byte[256]
			{
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35
			};
			_aLawCompressTableChunks[167] = new byte[256]
			{
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
				35, 35, 35, 35, 35, 35
			};
			_aLawCompressTableChunks[168] = new byte[256]
			{
				35, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32
			};
			_aLawCompressTableChunks[169] = new byte[256]
			{
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32
			};
			_aLawCompressTableChunks[170] = new byte[256]
			{
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32
			};
			_aLawCompressTableChunks[171] = new byte[256]
			{
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
				32, 32, 32, 32, 32, 32
			};
			_aLawCompressTableChunks[172] = new byte[256]
			{
				32, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33
			};
			_aLawCompressTableChunks[173] = new byte[256]
			{
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33
			};
			_aLawCompressTableChunks[174] = new byte[256]
			{
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33
			};
			_aLawCompressTableChunks[175] = new byte[256]
			{
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
				33, 33, 33, 33, 33, 33
			};
			_aLawCompressTableChunks[176] = new byte[256]
			{
				33, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38
			};
			_aLawCompressTableChunks[177] = new byte[256]
			{
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38
			};
			_aLawCompressTableChunks[178] = new byte[256]
			{
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38
			};
			_aLawCompressTableChunks[179] = new byte[256]
			{
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
				38, 38, 38, 38, 38, 38
			};
			_aLawCompressTableChunks[180] = new byte[256]
			{
				38, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39
			};
			_aLawCompressTableChunks[181] = new byte[256]
			{
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39
			};
			_aLawCompressTableChunks[182] = new byte[256]
			{
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39
			};
			_aLawCompressTableChunks[183] = new byte[256]
			{
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
				39, 39, 39, 39, 39, 39
			};
			_aLawCompressTableChunks[184] = new byte[256]
			{
				39, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36
			};
			_aLawCompressTableChunks[185] = new byte[256]
			{
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36
			};
			_aLawCompressTableChunks[186] = new byte[256]
			{
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36
			};
			_aLawCompressTableChunks[187] = new byte[256]
			{
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36
			};
			_aLawCompressTableChunks[188] = new byte[256]
			{
				36, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37
			};
			_aLawCompressTableChunks[189] = new byte[256]
			{
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37
			};
			_aLawCompressTableChunks[190] = new byte[256]
			{
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37
			};
			_aLawCompressTableChunks[191] = new byte[256]
			{
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
				37, 37, 37, 37, 37, 37
			};
		}

		private static void init192_223()
		{
			_aLawCompressTableChunks[192] = new byte[256]
			{
				37, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58
			};
			_aLawCompressTableChunks[193] = new byte[256]
			{
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
				58, 58, 58, 58, 58, 58
			};
			_aLawCompressTableChunks[194] = new byte[256]
			{
				58, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59
			};
			_aLawCompressTableChunks[195] = new byte[256]
			{
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
				59, 59, 59, 59, 59, 59
			};
			_aLawCompressTableChunks[196] = new byte[256]
			{
				59, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56
			};
			_aLawCompressTableChunks[197] = new byte[256]
			{
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
				56, 56, 56, 56, 56, 56
			};
			_aLawCompressTableChunks[198] = new byte[256]
			{
				56, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57
			};
			_aLawCompressTableChunks[199] = new byte[256]
			{
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
				57, 57, 57, 57, 57, 57
			};
			_aLawCompressTableChunks[200] = new byte[256]
			{
				57, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62
			};
			_aLawCompressTableChunks[201] = new byte[256]
			{
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
				62, 62, 62, 62, 62, 62
			};
			_aLawCompressTableChunks[202] = new byte[256]
			{
				62, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63
			};
			_aLawCompressTableChunks[203] = new byte[256]
			{
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
				63, 63, 63, 63, 63, 63
			};
			_aLawCompressTableChunks[204] = new byte[256]
			{
				63, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60
			};
			_aLawCompressTableChunks[205] = new byte[256]
			{
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
				60, 60, 60, 60, 60, 60
			};
			_aLawCompressTableChunks[206] = new byte[256]
			{
				60, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61
			};
			_aLawCompressTableChunks[207] = new byte[256]
			{
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
				61, 61, 61, 61, 61, 61
			};
			_aLawCompressTableChunks[208] = new byte[256]
			{
				61, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50
			};
			_aLawCompressTableChunks[209] = new byte[256]
			{
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
				50, 50, 50, 50, 50, 50
			};
			_aLawCompressTableChunks[210] = new byte[256]
			{
				50, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51
			};
			_aLawCompressTableChunks[211] = new byte[256]
			{
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
				51, 51, 51, 51, 51, 51
			};
			_aLawCompressTableChunks[212] = new byte[256]
			{
				51, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48
			};
			_aLawCompressTableChunks[213] = new byte[256]
			{
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
				48, 48, 48, 48, 48, 48
			};
			_aLawCompressTableChunks[214] = new byte[256]
			{
				48, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49
			};
			_aLawCompressTableChunks[215] = new byte[256]
			{
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
				49, 49, 49, 49, 49, 49
			};
			_aLawCompressTableChunks[216] = new byte[256]
			{
				49, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54
			};
			_aLawCompressTableChunks[217] = new byte[256]
			{
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
				54, 54, 54, 54, 54, 54
			};
			_aLawCompressTableChunks[218] = new byte[256]
			{
				54, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55
			};
			_aLawCompressTableChunks[219] = new byte[256]
			{
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
				55, 55, 55, 55, 55, 55
			};
			_aLawCompressTableChunks[220] = new byte[256]
			{
				55, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52
			};
			_aLawCompressTableChunks[221] = new byte[256]
			{
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
				52, 52, 52, 52, 52, 52
			};
			_aLawCompressTableChunks[222] = new byte[256]
			{
				52, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53
			};
			_aLawCompressTableChunks[223] = new byte[256]
			{
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
				53, 53, 53, 53, 53, 53
			};
		}

		private static void init224_255()
		{
			_aLawCompressTableChunks[224] = new byte[256]
			{
				53, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10
			};
			_aLawCompressTableChunks[225] = new byte[256]
			{
				10, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
				11, 11, 11, 11, 11, 11
			};
			_aLawCompressTableChunks[226] = new byte[256]
			{
				11, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8, 8, 8, 8, 8
			};
			_aLawCompressTableChunks[227] = new byte[256]
			{
				8, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
				9, 9, 9, 9, 9, 9
			};
			_aLawCompressTableChunks[228] = new byte[256]
			{
				9, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
				14, 14, 14, 14, 14, 14
			};
			_aLawCompressTableChunks[229] = new byte[256]
			{
				14, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
				15, 15, 15, 15, 15, 15
			};
			_aLawCompressTableChunks[230] = new byte[256]
			{
				15, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
				12, 12, 12, 12, 12, 12
			};
			_aLawCompressTableChunks[231] = new byte[256]
			{
				12, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
				13, 13, 13, 13, 13, 13
			};
			_aLawCompressTableChunks[232] = new byte[256]
			{
				13, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
				2, 2, 2, 2, 2, 2
			};
			_aLawCompressTableChunks[233] = new byte[256]
			{
				2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
				3, 3, 3, 3, 3, 3
			};
			byte[][] aLawCompressTableChunks = _aLawCompressTableChunks;
			byte[] array = new byte[256];
			array[0] = 3;
			aLawCompressTableChunks[234] = array;
			_aLawCompressTableChunks[235] = new byte[256]
			{
				0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
				1, 1, 1, 1, 1, 1
			};
			_aLawCompressTableChunks[236] = new byte[256]
			{
				1, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
				6, 6, 6, 6, 6, 6
			};
			_aLawCompressTableChunks[237] = new byte[256]
			{
				6, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
				7, 7, 7, 7, 7, 7
			};
			_aLawCompressTableChunks[238] = new byte[256]
			{
				7, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
				4, 4, 4, 4, 4, 4
			};
			_aLawCompressTableChunks[239] = new byte[256]
			{
				4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5, 5, 5, 5, 5
			};
			_aLawCompressTableChunks[240] = new byte[256]
			{
				5, 26, 26, 26, 26, 26, 26, 26, 26, 26,
				26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
				26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
				26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
				26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
				26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
				26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
				26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
				26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
				26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
				26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
				26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
				26, 26, 26, 26, 26, 26, 26, 26, 26, 27,
				27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
				27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
				27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
				27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
				27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
				27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
				27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
				27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
				27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
				27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
				27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
				27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
				27, 27, 27, 27, 27, 27
			};
			_aLawCompressTableChunks[241] = new byte[256]
			{
				27, 24, 24, 24, 24, 24, 24, 24, 24, 24,
				24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
				24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
				24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
				24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
				24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
				24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
				24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
				24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
				24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
				24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
				24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
				24, 24, 24, 24, 24, 24, 24, 24, 24, 25,
				25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
				25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
				25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
				25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
				25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
				25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
				25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
				25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
				25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
				25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
				25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
				25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
				25, 25, 25, 25, 25, 25
			};
			_aLawCompressTableChunks[242] = new byte[256]
			{
				25, 30, 30, 30, 30, 30, 30, 30, 30, 30,
				30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
				30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
				30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
				30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
				30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
				30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
				30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
				30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
				30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
				30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
				30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
				30, 30, 30, 30, 30, 30, 30, 30, 30, 31,
				31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
				31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
				31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
				31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
				31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
				31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
				31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
				31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
				31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
				31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
				31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
				31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
				31, 31, 31, 31, 31, 31
			};
			_aLawCompressTableChunks[243] = new byte[256]
			{
				31, 28, 28, 28, 28, 28, 28, 28, 28, 28,
				28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
				28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
				28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
				28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
				28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
				28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
				28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
				28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
				28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
				28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
				28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
				28, 28, 28, 28, 28, 28, 28, 28, 28, 29,
				29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
				29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
				29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
				29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
				29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
				29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
				29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
				29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
				29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
				29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
				29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
				29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
				29, 29, 29, 29, 29, 29
			};
			_aLawCompressTableChunks[244] = new byte[256]
			{
				29, 18, 18, 18, 18, 18, 18, 18, 18, 18,
				18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
				18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
				18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
				18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
				18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
				18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
				18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
				18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
				18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
				18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
				18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
				18, 18, 18, 18, 18, 18, 18, 18, 18, 19,
				19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
				19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
				19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
				19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
				19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
				19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
				19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
				19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
				19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
				19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
				19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
				19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
				19, 19, 19, 19, 19, 19
			};
			_aLawCompressTableChunks[245] = new byte[256]
			{
				19, 16, 16, 16, 16, 16, 16, 16, 16, 16,
				16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
				16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
				16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
				16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
				16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
				16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
				16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
				16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
				16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
				16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
				16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
				16, 16, 16, 16, 16, 16, 16, 16, 16, 17,
				17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
				17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
				17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
				17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
				17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
				17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
				17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
				17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
				17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
				17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
				17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
				17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
				17, 17, 17, 17, 17, 17
			};
			_aLawCompressTableChunks[246] = new byte[256]
			{
				17, 22, 22, 22, 22, 22, 22, 22, 22, 22,
				22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
				22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
				22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
				22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
				22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
				22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
				22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
				22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
				22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
				22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
				22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
				22, 22, 22, 22, 22, 22, 22, 22, 22, 23,
				23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
				23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
				23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
				23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
				23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
				23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
				23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
				23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
				23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
				23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
				23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
				23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
				23, 23, 23, 23, 23, 23
			};
			_aLawCompressTableChunks[247] = new byte[256]
			{
				23, 20, 20, 20, 20, 20, 20, 20, 20, 20,
				20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
				20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
				20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
				20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
				20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
				20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
				20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
				20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
				20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
				20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
				20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
				20, 20, 20, 20, 20, 20, 20, 20, 20, 21,
				21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
				21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
				21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
				21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
				21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
				21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
				21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
				21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
				21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
				21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
				21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
				21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
				21, 21, 21, 21, 21, 21
			};
			_aLawCompressTableChunks[248] = new byte[256]
			{
				21, 106, 106, 106, 106, 106, 106, 106, 106, 106,
				106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
				106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
				106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
				106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
				106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
				106, 106, 106, 106, 106, 107, 107, 107, 107, 107,
				107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
				107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
				107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
				107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
				107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
				107, 107, 107, 107, 107, 107, 107, 107, 107, 104,
				104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
				104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
				104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
				104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
				104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
				104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
				104, 104, 104, 105, 105, 105, 105, 105, 105, 105,
				105, 105, 105, 105, 105, 105, 105, 105, 105, 105,
				105, 105, 105, 105, 105, 105, 105, 105, 105, 105,
				105, 105, 105, 105, 105, 105, 105, 105, 105, 105,
				105, 105, 105, 105, 105, 105, 105, 105, 105, 105,
				105, 105, 105, 105, 105, 105, 105, 105, 105, 105,
				105, 105, 105, 105, 105, 105
			};
			_aLawCompressTableChunks[249] = new byte[256]
			{
				105, 110, 110, 110, 110, 110, 110, 110, 110, 110,
				110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
				110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
				110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
				110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
				110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
				110, 110, 110, 110, 110, 111, 111, 111, 111, 111,
				111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
				111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
				111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
				111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
				111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
				111, 111, 111, 111, 111, 111, 111, 111, 111, 108,
				108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
				108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
				108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
				108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
				108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
				108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
				108, 108, 108, 109, 109, 109, 109, 109, 109, 109,
				109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
				109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
				109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
				109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
				109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
				109, 109, 109, 109, 109, 109
			};
			_aLawCompressTableChunks[250] = new byte[256]
			{
				109, 98, 98, 98, 98, 98, 98, 98, 98, 98,
				98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
				98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
				98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
				98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
				98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
				98, 98, 98, 98, 98, 99, 99, 99, 99, 99,
				99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
				99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
				99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
				99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
				99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
				99, 99, 99, 99, 99, 99, 99, 99, 99, 96,
				96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
				96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
				96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
				96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
				96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
				96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
				96, 96, 96, 97, 97, 97, 97, 97, 97, 97,
				97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
				97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
				97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
				97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
				97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
				97, 97, 97, 97, 97, 97
			};
			_aLawCompressTableChunks[251] = new byte[256]
			{
				97, 102, 102, 102, 102, 102, 102, 102, 102, 102,
				102, 102, 102, 102, 102, 102, 102, 102, 102, 102,
				102, 102, 102, 102, 102, 102, 102, 102, 102, 102,
				102, 102, 102, 102, 102, 102, 102, 102, 102, 102,
				102, 102, 102, 102, 102, 102, 102, 102, 102, 102,
				102, 102, 102, 102, 102, 102, 102, 102, 102, 102,
				102, 102, 102, 102, 102, 103, 103, 103, 103, 103,
				103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
				103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
				103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
				103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
				103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
				103, 103, 103, 103, 103, 103, 103, 103, 103, 100,
				100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
				100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
				100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
				100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
				100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
				100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
				100, 100, 100, 101, 101, 101, 101, 101, 101, 101,
				101, 101, 101, 101, 101, 101, 101, 101, 101, 101,
				101, 101, 101, 101, 101, 101, 101, 101, 101, 101,
				101, 101, 101, 101, 101, 101, 101, 101, 101, 101,
				101, 101, 101, 101, 101, 101, 101, 101, 101, 101,
				101, 101, 101, 101, 101, 101, 101, 101, 101, 101,
				101, 101, 101, 101, 101, 101
			};
			_aLawCompressTableChunks[252] = new byte[256]
			{
				101, 122, 122, 122, 122, 122, 122, 122, 122, 122,
				122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
				122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
				122, 122, 122, 123, 123, 123, 123, 123, 123, 123,
				123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
				123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
				123, 123, 123, 123, 123, 120, 120, 120, 120, 120,
				120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
				120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
				120, 120, 120, 120, 120, 120, 120, 121, 121, 121,
				121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
				121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
				121, 121, 121, 121, 121, 121, 121, 121, 121, 126,
				126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
				126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
				126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
				126, 127, 127, 127, 127, 127, 127, 127, 127, 127,
				127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
				127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
				127, 127, 127, 124, 124, 124, 124, 124, 124, 124,
				124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
				124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
				124, 124, 124, 124, 124, 125, 125, 125, 125, 125,
				125, 125, 125, 125, 125, 125, 125, 125, 125, 125,
				125, 125, 125, 125, 125, 125, 125, 125, 125, 125,
				125, 125, 125, 125, 125, 125
			};
			_aLawCompressTableChunks[253] = new byte[256]
			{
				125, 114, 114, 114, 114, 114, 114, 114, 114, 114,
				114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
				114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
				114, 114, 114, 115, 115, 115, 115, 115, 115, 115,
				115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
				115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
				115, 115, 115, 115, 115, 112, 112, 112, 112, 112,
				112, 112, 112, 112, 112, 112, 112, 112, 112, 112,
				112, 112, 112, 112, 112, 112, 112, 112, 112, 112,
				112, 112, 112, 112, 112, 112, 112, 113, 113, 113,
				113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
				113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
				113, 113, 113, 113, 113, 113, 113, 113, 113, 118,
				118, 118, 118, 118, 118, 118, 118, 118, 118, 118,
				118, 118, 118, 118, 118, 118, 118, 118, 118, 118,
				118, 118, 118, 118, 118, 118, 118, 118, 118, 118,
				118, 119, 119, 119, 119, 119, 119, 119, 119, 119,
				119, 119, 119, 119, 119, 119, 119, 119, 119, 119,
				119, 119, 119, 119, 119, 119, 119, 119, 119, 119,
				119, 119, 119, 116, 116, 116, 116, 116, 116, 116,
				116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
				116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
				116, 116, 116, 116, 116, 117, 117, 117, 117, 117,
				117, 117, 117, 117, 117, 117, 117, 117, 117, 117,
				117, 117, 117, 117, 117, 117, 117, 117, 117, 117,
				117, 117, 117, 117, 117, 117
			};
			_aLawCompressTableChunks[254] = new byte[256]
			{
				117, 74, 74, 74, 74, 74, 74, 74, 74, 74,
				74, 74, 74, 74, 74, 74, 74, 75, 75, 75,
				75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
				75, 75, 75, 72, 72, 72, 72, 72, 72, 72,
				72, 72, 72, 72, 72, 72, 72, 72, 72, 73,
				73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
				73, 73, 73, 73, 73, 78, 78, 78, 78, 78,
				78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
				78, 79, 79, 79, 79, 79, 79, 79, 79, 79,
				79, 79, 79, 79, 79, 79, 79, 76, 76, 76,
				76, 76, 76, 76, 76, 76, 76, 76, 76, 76,
				76, 76, 76, 77, 77, 77, 77, 77, 77, 77,
				77, 77, 77, 77, 77, 77, 77, 77, 77, 66,
				66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
				66, 66, 66, 66, 66, 67, 67, 67, 67, 67,
				67, 67, 67, 67, 67, 67, 67, 67, 67, 67,
				67, 64, 64, 64, 64, 64, 64, 64, 64, 64,
				64, 64, 64, 64, 64, 64, 64, 65, 65, 65,
				65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
				65, 65, 65, 70, 70, 70, 70, 70, 70, 70,
				70, 70, 70, 70, 70, 70, 70, 70, 70, 71,
				71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
				71, 71, 71, 71, 71, 68, 68, 68, 68, 68,
				68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
				68, 69, 69, 69, 69, 69, 69, 69, 69, 69,
				69, 69, 69, 69, 69, 69
			};
			_aLawCompressTableChunks[255] = new byte[256]
			{
				69, 90, 90, 90, 90, 90, 90, 90, 90, 90,
				90, 90, 90, 90, 90, 90, 90, 91, 91, 91,
				91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
				91, 91, 91, 88, 88, 88, 88, 88, 88, 88,
				88, 88, 88, 88, 88, 88, 88, 88, 88, 89,
				89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
				89, 89, 89, 89, 89, 94, 94, 94, 94, 94,
				94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
				94, 95, 95, 95, 95, 95, 95, 95, 95, 95,
				95, 95, 95, 95, 95, 95, 95, 92, 92, 92,
				92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
				92, 92, 92, 93, 93, 93, 93, 93, 93, 93,
				93, 93, 93, 93, 93, 93, 93, 93, 93, 82,
				82, 82, 82, 82, 82, 82, 82, 82, 82, 82,
				82, 82, 82, 82, 82, 83, 83, 83, 83, 83,
				83, 83, 83, 83, 83, 83, 83, 83, 83, 83,
				83, 80, 80, 80, 80, 80, 80, 80, 80, 80,
				80, 80, 80, 80, 80, 80, 80, 81, 81, 81,
				81, 81, 81, 81, 81, 81, 81, 81, 81, 81,
				81, 81, 81, 86, 86, 86, 86, 86, 86, 86,
				86, 86, 86, 86, 86, 86, 86, 86, 86, 87,
				87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
				87, 87, 87, 87, 87, 84, 84, 84, 84, 84,
				84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
				84, 85, 85, 85, 85, 85, 85, 85, 85, 85,
				85, 85, 85, 85, 85, 85
			};
		}
	}
}
namespace Steamworks
{
	internal struct CallResult<T> : INotifyCompletion where T : struct, ICallbackData
	{
		private SteamAPICall_t call;

		private ISteamUtils utils;

		private bool server;

		public bool IsCompleted
		{
			get
			{
				bool pbFailed = false;
				if (utils.IsAPICallCompleted(call, ref pbFailed) || pbFailed)
				{
					return true;
				}
				return false;
			}
		}

		public CallResult(SteamAPICall_t call, bool server)
		{
			this.call = call;
			this.server = server;
			utils = (server ? SteamSharedClass<SteamUtils>.InterfaceServer : SteamSharedClass<SteamUtils>.InterfaceClient) as ISteamUtils;
			if (utils == null)
			{
				utils = SteamSharedClass<SteamUtils>.Interface as ISteamUtils;
			}
		}

		public void OnCompleted(Action continuation)
		{
			Dispatch.OnCallComplete<T>(call, continuation, server);
		}

		public T? GetResult()
		{
			bool pbFailed = false;
			if (!utils.IsAPICallCompleted(call, ref pbFailed) || pbFailed)
			{
				return null;
			}
			T val = default(T);
			int dataSize = val.DataSize;
			IntPtr intPtr = Marshal.AllocHGlobal(dataSize);
			try
			{
				if (!utils.GetAPICallResult(call, intPtr, dataSize, (int)val.CallbackType, ref pbFailed) || pbFailed)
				{
					Dispatch.OnDebugCallback?.Invoke(val.CallbackType, "!GetAPICallResult or failed", server);
					return null;
				}
				Dispatch.OnDebugCallback?.Invoke(val.CallbackType, Dispatch.CallbackToString(val.CallbackType, intPtr, dataSize), server);
				return (T)Marshal.PtrToStructure(intPtr, typeof(T));
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		internal CallResult<T> GetAwaiter()
		{
			return this;
		}
	}
	internal interface ICallbackData
	{
		CallbackType CallbackType { get; }

		int DataSize { get; }
	}
	public class AuthTicket : IDisposable
	{
		public byte[] Data;

		public uint Handle;

		public void Cancel()
		{
			if (Handle != 0)
			{
				SteamUser.Internal.CancelAuthTicket(Handle);
			}
			Handle = 0u;
			Data = null;
		}

		public void Dispose()
		{
			Cancel();
		}
	}
	public static class Dispatch
	{
		[StructLayout(LayoutKind.Sequential, Pack = 8)]
		internal struct CallbackMsg_t
		{
			public HSteamUser m_hSteamUser;

			public CallbackType Type;

			public IntPtr Data;

			public int DataSize;
		}

		private struct ResultCallback
		{
			public Action continuation;

			public bool server;
		}

		private struct Callback
		{
			public Action<IntPtr> action;

			public bool server;
		}

		public static Action<CallbackType, string, bool> OnDebugCallback;

		public static Action<Exception> OnException;

		private static bool runningFrame = false;

		private static List<Action<IntPtr>> actionsToCall = new List<Action<IntPtr>>();

		private static Dictionary<ulong, ResultCallback> ResultCallbacks = new Dictionary<ulong, ResultCallback>();

		private static Dictionary<CallbackType, List<Callback>> Callbacks = new Dictionary<CallbackType, List<Callback>>();

		internal static HSteamPipe ClientPipe { get; set; }

		internal static HSteamPipe ServerPipe { get; set; }

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern void SteamAPI_ManualDispatch_Init();

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern void SteamAPI_ManualDispatch_RunFrame(HSteamPipe pipe);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool SteamAPI_ManualDispatch_GetNextCallback(HSteamPipe pipe, [In][Out] ref CallbackMsg_t msg);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool SteamAPI_ManualDispatch_FreeLastCallback(HSteamPipe pipe);

		internal static void Init()
		{
			SteamAPI_ManualDispatch_Init();
		}

		internal static void Frame(HSteamPipe pipe)
		{
			if (runningFrame)
			{
				return;
			}
			try
			{
				runningFrame = true;
				SteamAPI_ManualDispatch_RunFrame(pipe);
				SteamNetworkingUtils.OutputDebugMessages();
				CallbackMsg_t msg = default(CallbackMsg_t);
				while (SteamAPI_ManualDispatch_GetNextCallback(pipe, ref msg))
				{
					try
					{
						ProcessCallback(msg, pipe == ServerPipe);
					}
					finally
					{
						SteamAPI_ManualDispatch_FreeLastCallback(pipe);
					}
				}
			}
			catch (Exception obj)
			{
				OnException?.Invoke(obj);
			}
			finally
			{
				runningFrame = false;
			}
		}

		private static void ProcessCallback(CallbackMsg_t msg, bool isServer)
		{
			OnDebugCallback?.Invoke(msg.Type, CallbackToString(msg.Type, msg.Data, msg.DataSize), isServer);
			if (msg.Type == CallbackType.SteamAPICallCompleted)
			{
				ProcessResult(msg);
			}
			else
			{
				if (!Callbacks.TryGetValue(msg.Type, out var value))
				{
					return;
				}
				actionsToCall.Clear();
				foreach (Callback item in value)
				{
					if (item.server == isServer)
					{
						actionsToCall.Add(item.action);
					}
				}
				foreach (Action<IntPtr> item2 in actionsToCall)
				{
					item2(msg.Data);
				}
				actionsToCall.Clear();
			}
		}

		internal static string CallbackToString(CallbackType type, IntPtr data, int expectedsize)
		{
			if (!CallbackTypeFactory.All.TryGetValue(type, out var value))
			{
				return $"[{type} not in sdk]";
			}
			object obj = data.ToType(value);
			if (obj == null)
			{
				return "[null]";
			}
			string text = "";
			FieldInfo[] fields = value.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (fields.Length == 0)
			{
				return "[no fields]";
			}
			int num = fields.Max((FieldInfo x) => x.Name.Length) + 1;
			if (num < 10)
			{
				num = 10;
			}
			FieldInfo[] array = fields;
			foreach (FieldInfo fieldInfo in array)
			{
				int num2 = num - fieldInfo.Name.Length;
				if (num2 < 0)
				{
					num2 = 0;
				}
				text += $"{new string(' ', num2)}{fieldInfo.Name}: {fieldInfo.GetValue(obj)}\n";
			}
			return text.Trim('\n');
		}

		private static void ProcessResult(CallbackMsg_t msg)
		{
			SteamAPICallCompleted_t steamAPICallCompleted_t = msg.Data.ToType<SteamAPICallCompleted_t>();
			if (!ResultCallbacks.TryGetValue(steamAPICallCompleted_t.AsyncCall, out var value))
			{
				OnDebugCallback?.Invoke((CallbackType)steamAPICallCompleted_t.Callback, "[no callback waiting/required]", arg3: false);
				return;
			}
			ResultCallbacks.Remove(steamAPICallCompleted_t.AsyncCall);
			value.continuation();
		}

		internal static async void LoopClientAsync()
		{
			while (ClientPipe != 0)
			{
				Frame(ClientPipe);
				await Task.Delay(16);
			}
		}

		internal static async void LoopServerAsync()
		{
			while (ServerPipe != 0)
			{
				Frame(ServerPipe);
				await Task.Delay(32);
			}
		}

		internal static void OnCallComplete<T>(SteamAPICall_t call, Action continuation, bool server) where T : struct, ICallbackData
		{
			ResultCallbacks[call.Value] = new ResultCallback
			{
				continuation = continuation,
				server = server
			};
		}

		internal static void Install<T>(Action<T> p, bool server = false) where T : ICallbackData
		{
			CallbackType callbackType = default(T).CallbackType;
			if (!Callbacks.TryGetValue(callbackType, out var value))
			{
				value = new List<Callback>();
				Callbacks[callbackType] = value;
			}
			value.Add(new Callback
			{
				action = delegate(IntPtr x)
				{
					p(x.ToType<T>());
				},
				server = server
			});
		}

		internal static void ShutdownServer()
		{
			ServerPipe = 0;
			foreach (KeyValuePair<CallbackType, List<Callback>> callback in Callbacks)
			{
				Callbacks[callback.Key].RemoveAll((Callback x) => x.server);
			}
			ResultCallbacks = ResultCallbacks.Where((KeyValuePair<ulong, ResultCallback> x) => !x.Value.server).ToDictionary((KeyValuePair<ulong, ResultCallback> x) => x.Key, (KeyValuePair<ulong, ResultCallback> x) => x.Value);
		}

		internal static void ShutdownClient()
		{
			ClientPipe = 0;
			foreach (KeyValuePair<CallbackType, List<Callback>> callback in Callbacks)
			{
				Callbacks[callback.Key].RemoveAll((Callback x) => !x.server);
			}
			ResultCallbacks = ResultCallbacks.Where((KeyValuePair<ulong, ResultCallback> x) => x.Value.server).ToDictionary((KeyValuePair<ulong, ResultCallback> x) => x.Key, (KeyValuePair<ulong, ResultCallback> x) => x.Value);
		}
	}
	internal static class SteamAPI
	{
		internal static class Native
		{
			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			[return: MarshalAs(UnmanagedType.I1)]
			public static extern bool SteamAPI_Init();

			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			public static extern void SteamAPI_Shutdown();

			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			public static extern HSteamPipe SteamAPI_GetHSteamPipe();

			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			[return: MarshalAs(UnmanagedType.I1)]
			public static extern bool SteamAPI_RestartAppIfNecessary(uint unOwnAppID);
		}

		internal static bool Init()
		{
			return Native.SteamAPI_Init();
		}

		internal static void Shutdown()
		{
			Native.SteamAPI_Shutdown();
		}

		internal static HSteamPipe GetHSteamPipe()
		{
			return Native.SteamAPI_GetHSteamPipe();
		}

		internal static bool RestartAppIfNecessary(uint unOwnAppID)
		{
			return Native.SteamAPI_RestartAppIfNecessary(unOwnAppID);
		}
	}
	internal static class SteamGameServer
	{
		internal static class Native
		{
			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			public static extern void SteamGameServer_RunCallbacks();

			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			public static extern void SteamGameServer_Shutdown();

			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			public static extern HSteamPipe SteamGameServer_GetHSteamPipe();
		}

		internal static void RunCallbacks()
		{
			Native.SteamGameServer_RunCallbacks();
		}

		internal static void Shutdown()
		{
			Native.SteamGameServer_Shutdown();
		}

		internal static HSteamPipe GetHSteamPipe()
		{
			return Native.SteamGameServer_GetHSteamPipe();
		}
	}
	internal static class SteamInternal
	{
		internal static class Native
		{
			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			[return: MarshalAs(UnmanagedType.I1)]
			public static extern bool SteamInternal_GameServer_Init(uint unIP, ushort usPort, ushort usGamePort, ushort usQueryPort, int eServerMode, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersionString);
		}

		internal static bool GameServer_Init(uint unIP, ushort usPort, ushort usGamePort, ushort usQueryPort, int eServerMode, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersionString)
		{
			return Native.SteamInternal_GameServer_Init(unIP, usPort, usGamePort, usQueryPort, eServerMode, pchVersionString);
		}
	}
	public enum CallbackType
	{
		SteamServersConnected = 101,
		SteamServerConnectFailure = 102,
		SteamServersDisconnected = 103,
		ClientGameServerDeny = 113,
		GSPolicyResponse = 115,
		IPCFailure = 117,
		LicensesUpdated = 125,
		ValidateAuthTicketResponse = 143,
		MicroTxnAuthorizationResponse = 152,
		EncryptedAppTicketResponse = 154,
		GetAuthSessionTicketResponse = 163,
		GameWebCallback = 164,
		StoreAuthURLResponse = 165,
		MarketEligibilityResponse = 166,
		DurationControl = 167,
		GSClientApprove = 201,
		GSClientDeny = 202,
		GSClientKick = 203,
		GSClientAchievementStatus = 206,
		GSGameplayStats = 207,
		GSClientGroupStatus = 208,
		GSReputation = 209,
		AssociateWithClanResult = 210,
		ComputeNewPlayerCompatibilityResult = 211,
		PersonaStateChange = 304,
		GameOverlayActivated = 331,
		GameServerChangeRequested = 332,
		GameLobbyJoinRequested = 333,
		AvatarImageLoaded = 334,
		ClanOfficerListResponse = 335,
		FriendRichPresenceUpdate = 336,
		GameRichPresenceJoinRequested = 337,
		GameConnectedClanChatMsg = 338,
		GameConnectedChatJoin = 339,
		GameConnectedChatLeave = 340,
		DownloadClanActivityCountsResult = 341,
		JoinClanChatRoomCompletionResult = 342,
		GameConnectedFriendChatMsg = 343,
		FriendsGetFollowerCount = 344,
		FriendsIsFollowing = 345,
		FriendsEnumerateFollowingList = 346,
		SetPersonaNameResponse = 347,
		UnreadChatMessagesChanged = 348,
		FavoritesListChanged = 502,
		LobbyInvite = 503,
		LobbyEnter = 504,
		LobbyDataUpdate = 505,
		LobbyChatUpdate = 506,
		LobbyChatMsg = 507,
		LobbyGameCreated = 509,
		LobbyMatchList = 510,
		LobbyKicked = 512,
		LobbyCreated = 513,
		PSNGameBootInviteResult = 515,
		FavoritesListAccountsUpdated = 516,
		IPCountry = 701,
		LowBatteryPower = 702,
		SteamAPICallCompleted = 703,
		SteamShutdown = 704,
		CheckFileSignature = 705,
		GamepadTextInputDismissed = 714,
		DlcInstalled = 1005,
		RegisterActivationCodeResponse = 1008,
		NewUrlLaunchParameters = 1014,
		AppProofOfPurchaseKeyResponse = 1021,
		FileDetailsResult = 1023,
		UserStatsReceived = 1101,
		UserStatsStored = 1102,
		UserAchievementStored = 1103,
		LeaderboardFindResult = 1104,
		LeaderboardScoresDownloaded = 1105,
		LeaderboardScoreUploaded = 1106,
		NumberOfCurrentPlayers = 1107,
		UserStatsUnloaded = 1108,
		GSStatsUnloaded = 1108,
		UserAchievementIconFetched = 1109,
		GlobalAchievementPercentagesReady = 1110,
		LeaderboardUGCSet = 1111,
		GlobalStatsReceived = 1112,
		P2PSessionRequest = 1202,
		P2PSessionConnectFail = 1203,
		SteamNetConnectionStatusChangedCallback = 1221,
		SteamNetAuthenticationStatus = 1222,
		SteamRelayNetworkStatus = 1281,
		RemoteStorageAppSyncedClient = 1301,
		RemoteStorageAppSyncedServer = 1302,
		RemoteStorageAppSyncProgress = 1303,
		RemoteStorageAppSyncStatusCheck = 1305,
		RemoteStorageFileShareResult = 1307,
		RemoteStoragePublishFileResult = 1309,
		RemoteStorageDeletePublishedFileResult = 1311,
		RemoteStorageEnumerateUserPublishedFilesResult = 1312,
		RemoteStorageSubscribePublishedFileResult = 1313,
		RemoteStorageEnumerateUserSubscribedFilesResult = 1314,
		RemoteStorageUnsubscribePublishedFileResult = 1315,
		RemoteStorageUpdatePublishedFileResult = 1316,
		RemoteStorageDownloadUGCResult = 1317,
		RemoteStorageGetPublishedFileDetailsResult = 1318,
		RemoteStorageEnumerateWorkshopFilesResult = 1319,
		RemoteStorageGetPublishedItemVoteDetailsResult = 1320,
		RemoteStoragePublishedFileSubscribed = 1321,
		RemoteStoragePublishedFileUnsubscribed = 1322,
		RemoteStoragePublishedFileDeleted = 1323,
		RemoteStorageUpdateUserPublishedItemVoteResult = 1324,
		RemoteStorageUserVoteDetails = 1325,
		RemoteStorageEnumerateUserSharedWorkshopFilesResult = 1326,
		RemoteStorageSetUserPublishedFileActionResult = 1327,
		RemoteStorageEnumeratePublishedFilesByUserActionResult = 1328,
		RemoteStoragePublishFileProgress = 1329,
		RemoteStoragePublishedFileUpdated = 1330,
		RemoteStorageFileWriteAsyncComplete = 1331,
		RemoteStorageFileReadAsyncComplete = 1332,
		GSStatsReceived = 1800,
		GSStatsStored = 1801,
		HTTPRequestCompleted = 2101,
		HTTPRequestHeadersReceived = 2102,
		HTTPRequestDataReceived = 2103,
		ScreenshotReady = 2301,
		ScreenshotRequested = 2302,
		SteamUGCQueryCompleted = 3401,
		SteamUGCRequestUGCDetailsResult = 3402,
		CreateItemResult = 3403,
		SubmitItemUpdateResult = 3404,
		ItemInstalled = 3405,
		DownloadItemResult = 3406,
		UserFavoriteItemsListChanged = 3407,
		SetUserItemVoteResult = 3408,
		GetUserItemVoteResult = 3409,
		StartPlaytimeTrackingResult = 3410,
		StopPlaytimeTrackingResult = 3411,
		AddUGCDependencyResult = 3412,
		RemoveUGCDependencyResult = 3413,
		AddAppDependencyResult = 3414,
		RemoveAppDependencyResult = 3415,
		GetAppDependenciesResult = 3416,
		DeleteItemResult = 3417,
		SteamAppInstalled = 3901,
		SteamAppUninstalled = 3902,
		PlaybackStatusHasChanged = 4001,
		VolumeHasChanged = 4002,
		MusicPlayerWantsVolume = 4011,
		MusicPlayerSelectsQueueEntry = 4012,
		MusicPlayerSelectsPlaylistEntry = 4013,
		MusicPlayerRemoteWillActivate = 4101,
		MusicPlayerRemoteWillDeactivate = 4102,
		MusicPlayerRemoteToFront = 4103,
		MusicPlayerWillQuit = 4104,
		MusicPlayerWantsPlay = 4105,
		MusicPlayerWantsPause = 4106,
		MusicPlayerWantsPlayPrevious = 4107,
		MusicPlayerWantsPlayNext = 4108,
		MusicPlayerWantsShuffled = 4109,
		MusicPlayerWantsLooped = 4110,
		MusicPlayerWantsPlayingRepeatStatus = 4114,
		HTML_BrowserReady = 4501,
		HTML_NeedsPaint = 4502,
		HTML_StartRequest = 4503,
		HTML_CloseBrowser = 4504,
		HTML_URLChanged = 4505,
		HTML_FinishedRequest = 4506,
		HTML_OpenLinkInNewTab = 4507,
		HTML_ChangedTitle = 4508,
		HTML_SearchResults = 4509,
		HTML_CanGoBackAndForward = 4510,
		HTML_HorizontalScroll = 4511,
		HTML_VerticalScroll = 4512,
		HTML_LinkAtPosition = 4513,
		HTML_JSAlert = 4514,
		HTML_JSConfirm = 4515,
		HTML_FileOpenDialog = 4516,
		HTML_NewWindow = 4521,
		HTML_SetCursor = 4522,
		HTML_StatusText = 4523,
		HTML_ShowToolTip = 4524,
		HTML_UpdateToolTip = 4525,
		HTML_HideToolTip = 4526,
		HTML_BrowserRestarted = 4527,
		BroadcastUploadStart = 4604,
		BroadcastUploadStop = 4605,
		GetVideoURLResult = 4611,
		GetOPFSettingsResult = 4624,
		SteamInventoryResultReady = 4700,
		SteamInventoryFullUpdate = 4701,
		SteamInventoryDefinitionUpdate = 4702,
		SteamInventoryEligiblePromoItemDefIDs = 4703,
		SteamInventoryStartPurchaseResult = 4704,
		SteamInventoryRequestPricesResult = 4705,
		SteamParentalSettingsChanged = 5001,
		SearchForGameProgressCallback = 5201,
		SearchForGameResultCallback = 5202,
		RequestPlayersForGameProgressCallback = 5211,
		RequestPlayersForGameResultCallback = 5212,
		RequestPlayersForGameFinalResultCallback = 5213,
		SubmitPlayerResultResultCallback = 5214,
		EndGameResultCallback = 5215,
		JoinPartyCallback = 5301,
		CreateBeaconCallback = 5302,
		ReservationNotificationCallback = 5303,
		ChangeNumOpenSlotsCallback = 5304,
		AvailableBeaconLocationsUpdated = 5305,
		ActiveBeaconsUpdated = 5306,
		SteamRemotePlaySessionConnected = 5701,
		SteamRemotePlaySessionDisconnected = 5702
	}
	internal static class CallbackTypeFactory
	{
		internal static Dictionary<CallbackType, Type> All = new Dictionary<CallbackType, Type>
		{
			{
				CallbackType.SteamServersConnected,
				typeof(SteamServersConnected_t)
			},
			{
				CallbackType.SteamServerConnectFailure,
				typeof(SteamServerConnectFailure_t)
			},
			{
				CallbackType.SteamServersDisconnected,
				typeof(SteamServersDisconnected_t)
			},
			{
				CallbackType.ClientGameServerDeny,
				typeof(ClientGameServerDeny_t)
			},
			{
				CallbackType.GSPolicyResponse,
				typeof(GSPolicyResponse_t)
			},
			{
				CallbackType.IPCFailure,
				typeof(IPCFailure_t)
			},
			{
				CallbackType.LicensesUpdated,
				typeof(LicensesUpdated_t)
			},
			{
				CallbackType.ValidateAuthTicketResponse,
				typeof(ValidateAuthTicketResponse_t)
			},
			{
				CallbackType.MicroTxnAuthorizationResponse,
				typeof(MicroTxnAuthorizationResponse_t)
			},
			{
				CallbackType.EncryptedAppTicketResponse,
				typeof(EncryptedAppTicketResponse_t)
			},
			{
				CallbackType.GetAuthSessionTicketResponse,
				typeof(GetAuthSessionTicketResponse_t)
			},
			{
				CallbackType.GameWebCallback,
				typeof(GameWebCallback_t)
			},
			{
				CallbackType.StoreAuthURLResponse,
				typeof(StoreAuthURLResponse_t)
			},
			{
				CallbackType.MarketEligibilityResponse,
				typeof(MarketEligibilityResponse_t)
			},
			{
				CallbackType.DurationControl,
				typeof(DurationControl_t)
			},
			{
				CallbackType.GSClientApprove,
				typeof(GSClientApprove_t)
			},
			{
				CallbackType.GSClientDeny,
				typeof(GSClientDeny_t)
			},
			{
				CallbackType.GSClientKick,
				typeof(GSClientKick_t)
			},
			{
				CallbackType.GSClientAchievementStatus,
				typeof(GSClientAchievementStatus_t)
			},
			{
				CallbackType.GSGameplayStats,
				typeof(GSGameplayStats_t)
			},
			{
				CallbackType.GSClientGroupStatus,
				typeof(GSClientGroupStatus_t)
			},
			{
				CallbackType.GSReputation,
				typeof(GSReputation_t)
			},
			{
				CallbackType.AssociateWithClanResult,
				typeof(AssociateWithClanResult_t)
			},
			{
				CallbackType.ComputeNewPlayerCompatibilityResult,
				typeof(ComputeNewPlayerCompatibilityResult_t)
			},
			{
				CallbackType.PersonaStateChange,
				typeof(PersonaStateChange_t)
			},
			{
				CallbackType.GameOverlayActivated,
				typeof(GameOverlayActivated_t)
			},
			{
				CallbackType.GameServerChangeRequested,
				typeof(GameServerChangeRequested_t)
			},
			{
				CallbackType.GameLobbyJoinRequested,
				typeof(GameLobbyJoinRequested_t)
			},
			{
				CallbackType.AvatarImageLoaded,
				typeof(AvatarImageLoaded_t)
			},
			{
				CallbackType.ClanOfficerListResponse,
				typeof(ClanOfficerListResponse_t)
			},
			{
				CallbackType.FriendRichPresenceUpdate,
				typeof(FriendRichPresenceUpdate_t)
			},
			{
				CallbackType.GameRichPresenceJoinRequested,
				typeof(GameRichPresenceJoinRequested_t)
			},
			{
				CallbackType.GameConnectedClanChatMsg,
				typeof(GameConnectedClanChatMsg_t)
			},
			{
				CallbackType.GameConnectedChatJoin,
				typeof(GameConnectedChatJoin_t)
			},
			{
				CallbackType.GameConnectedChatLeave,
				typeof(GameConnectedChatLeave_t)
			},
			{
				CallbackType.DownloadClanActivityCountsResult,
				typeof(DownloadClanActivityCountsResult_t)
			},
			{
				CallbackType.JoinClanChatRoomCompletionResult,
				typeof(JoinClanChatRoomCompletionResult_t)
			},
			{
				CallbackType.GameConnectedFriendChatMsg,
				typeof(GameConnectedFriendChatMsg_t)
			},
			{
				CallbackType.FriendsGetFollowerCount,
				typeof(FriendsGetFollowerCount_t)
			},
			{
				CallbackType.FriendsIsFollowing,
				typeof(FriendsIsFollowing_t)
			},
			{
				CallbackType.FriendsEnumerateFollowingList,
				typeof(FriendsEnumerateFollowingList_t)
			},
			{
				CallbackType.SetPersonaNameResponse,
				typeof(SetPersonaNameResponse_t)
			},
			{
				CallbackType.UnreadChatMessagesChanged,
				typeof(UnreadChatMessagesChanged_t)
			},
			{
				CallbackType.FavoritesListChanged,
				typeof(FavoritesListChanged_t)
			},
			{
				CallbackType.LobbyInvite,
				typeof(LobbyInvite_t)
			},
			{
				CallbackType.LobbyEnter,
				typeof(LobbyEnter_t)
			},
			{
				CallbackType.LobbyDataUpdate,
				typeof(LobbyDataUpdate_t)
			},
			{
				CallbackType.LobbyChatUpdate,
				typeof(LobbyChatUpdate_t)
			},
			{
				CallbackType.LobbyChatMsg,
				typeof(LobbyChatMsg_t)
			},
			{
				CallbackType.LobbyGameCreated,
				typeof(LobbyGameCreated_t)
			},
			{
				CallbackType.LobbyMatchList,
				typeof(LobbyMatchList_t)
			},
			{
				CallbackType.LobbyKicked,
				typeof(LobbyKicked_t)
			},
			{
				CallbackType.LobbyCreated,
				typeof(LobbyCreated_t)
			},
			{
				CallbackType.PSNGameBootInviteResult,
				typeof(PSNGameBootInviteResult_t)
			},
			{
				CallbackType.FavoritesListAccountsUpdated,
				typeof(FavoritesListAccountsUpdated_t)
			},
			{
				CallbackType.IPCountry,
				typeof(IPCountry_t)
			},
			{
				CallbackType.LowBatteryPower,
				typeof(LowBatteryPower_t)
			},
			{
				CallbackType.SteamAPICallCompleted,
				typeof(SteamAPICallCompleted_t)
			},
			{
				CallbackType.SteamShutdown,
				typeof(SteamShutdown_t)
			},
			{
				CallbackType.CheckFileSignature,
				typeof(CheckFileSignature_t)
			},
			{
				CallbackType.GamepadTextInputDismissed,
				typeof(GamepadTextInputDismissed_t)
			},
			{
				CallbackType.DlcInstalled,
				typeof(DlcInstalled_t)
			},
			{
				CallbackType.RegisterActivationCodeResponse,
				typeof(RegisterActivationCodeResponse_t)
			},
			{
				CallbackType.NewUrlLaunchParameters,
				typeof(NewUrlLaunchParameters_t)
			},
			{
				CallbackType.AppProofOfPurchaseKeyResponse,
				typeof(AppProofOfPurchaseKeyResponse_t)
			},
			{
				CallbackType.FileDetailsResult,
				typeof(FileDetailsResult_t)
			},
			{
				CallbackType.UserStatsReceived,
				typeof(UserStatsReceived_t)
			},
			{
				CallbackType.UserStatsStored,
				typeof(UserStatsStored_t)
			},
			{
				CallbackType.UserAchievementStored,
				typeof(UserAchievementStored_t)
			},
			{
				CallbackType.LeaderboardFindResult,
				typeof(LeaderboardFindResult_t)
			},
			{
				CallbackType.LeaderboardScoresDownloaded,
				typeof(LeaderboardScoresDownloaded_t)
			},
			{
				CallbackType.LeaderboardScoreUploaded,
				typeof(LeaderboardScoreUploaded_t)
			},
			{
				CallbackType.NumberOfCurrentPlayers,
				typeof(NumberOfCurrentPlayers_t)
			},
			{
				CallbackType.UserStatsUnloaded,
				typeof(UserStatsUnloaded_t)
			},
			{
				CallbackType.UserAchievementIconFetched,
				typeof(UserAchievementIconFetched_t)
			},
			{
				CallbackType.GlobalAchievementPercentagesReady,
				typeof(GlobalAchievementPercentagesReady_t)
			},
			{
				CallbackType.LeaderboardUGCSet,
				typeof(LeaderboardUGCSet_t)
			},
			{
				CallbackType.GlobalStatsReceived,
				typeof(GlobalStatsReceived_t)
			},
			{
				CallbackType.P2PSessionRequest,
				typeof(P2PSessionRequest_t)
			},
			{
				CallbackType.P2PSessionConnectFail,
				typeof(P2PSessionConnectFail_t)
			},
			{
				CallbackType.SteamNetConnectionStatusChangedCallback,
				typeof(SteamNetConnectionStatusChangedCallback_t)
			},
			{
				CallbackType.SteamNetAuthenticationStatus,
				typeof(SteamNetAuthenticationStatus_t)
			},
			{
				CallbackType.SteamRelayNetworkStatus,
				typeof(SteamRelayNetworkStatus_t)
			},
			{
				CallbackType.RemoteStorageAppSyncedClient,
				typeof(RemoteStorageAppSyncedClient_t)
			},
			{
				CallbackType.RemoteStorageAppSyncedServer,
				typeof(RemoteStorageAppSyncedServer_t)
			},
			{
				CallbackType.RemoteStorageAppSyncProgress,
				typeof(RemoteStorageAppSyncProgress_t)
			},
			{
				CallbackType.RemoteStorageAppSyncStatusCheck,
				typeof(RemoteStorageAppSyncStatusCheck_t)
			},
			{
				CallbackType.RemoteStorageFileShareResult,
				typeof(RemoteStorageFileShareResult_t)
			},
			{
				CallbackType.RemoteStoragePublishFileResult,
				typeof(RemoteStoragePublishFileResult_t)
			},
			{
				CallbackType.RemoteStorageDeletePublishedFileResult,
				typeof(RemoteStorageDeletePublishedFileResult_t)
			},
			{
				CallbackType.RemoteStorageEnumerateUserPublishedFilesResult,
				typeof(RemoteStorageEnumerateUserPublishedFilesResult_t)
			},
			{
				CallbackType.RemoteStorageSubscribePublishedFileResult,
				typeof(RemoteStorageSubscribePublishedFileResult_t)
			},
			{
				CallbackType.RemoteStorageEnumerateUserSubscribedFilesResult,
				typeof(RemoteStorageEnumerateUserSubscribedFilesResult_t)
			},
			{
				CallbackType.RemoteStorageUnsubscribePublishedFileResult,
				typeof(RemoteStorageUnsubscribePublishedFileResult_t)
			},
			{
				CallbackType.RemoteStorageUpdatePublishedFileResult,
				typeof(RemoteStorageUpdatePublishedFileResult_t)
			},
			{
				CallbackType.RemoteStorageDownloadUGCResult,
				typeof(RemoteStorageDownloadUGCResult_t)
			},
			{
				CallbackType.RemoteStorageGetPublishedFileDetailsResult,
				typeof(RemoteStorageGetPublishedFileDetailsResult_t)
			},
			{
				CallbackType.RemoteStorageEnumerateWorkshopFilesResult,
				typeof(RemoteStorageEnumerateWorkshopFilesResult_t)
			},
			{
				CallbackType.RemoteStorageGetPublishedItemVoteDetailsResult,
				typeof(RemoteStorageGetPublishedItemVoteDetailsResult_t)
			},
			{
				CallbackType.RemoteStoragePublishedFileSubscribed,
				typeof(RemoteStoragePublishedFileSubscribed_t)
			},
			{
				CallbackType.RemoteStoragePublishedFileUnsubscribed,
				typeof(RemoteStoragePublishedFileUnsubscribed_t)
			},
			{
				CallbackType.RemoteStoragePublishedFileDeleted,
				typeof(RemoteStoragePublishedFileDeleted_t)
			},
			{
				CallbackType.RemoteStorageUpdateUserPublishedItemVoteResult,
				typeof(RemoteStorageUpdateUserPublishedItemVoteResult_t)
			},
			{
				CallbackType.RemoteStorageUserVoteDetails,
				typeof(RemoteStorageUserVoteDetails_t)
			},
			{
				CallbackType.RemoteStorageEnumerateUserSharedWorkshopFilesResult,
				typeof(RemoteStorageEnumerateUserSharedWorkshopFilesResult_t)
			},
			{
				CallbackType.RemoteStorageSetUserPublishedFileActionResult,
				typeof(RemoteStorageSetUserPublishedFileActionResult_t)
			},
			{
				CallbackType.RemoteStorageEnumeratePublishedFilesByUserActionResult,
				typeof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t)
			},
			{
				CallbackType.RemoteStoragePublishFileProgress,
				typeof(RemoteStoragePublishFileProgress_t)
			},
			{
				CallbackType.RemoteStoragePublishedFileUpdated,
				typeof(RemoteStoragePublishedFileUpdated_t)
			},
			{
				CallbackType.RemoteStorageFileWriteAsyncComplete,
				typeof(RemoteStorageFileWriteAsyncComplete_t)
			},
			{
				CallbackType.RemoteStorageFileReadAsyncComplete,
				typeof(RemoteStorageFileReadAsyncComplete_t)
			},
			{
				CallbackType.GSStatsReceived,
				typeof(GSStatsReceived_t)
			},
			{
				CallbackType.GSStatsStored,
				typeof(GSStatsStored_t)
			},
			{
				CallbackType.HTTPRequestCompleted,
				typeof(HTTPRequestCompleted_t)
			},
			{
				CallbackType.HTTPRequestHeadersReceived,
				typeof(HTTPRequestHeadersReceived_t)
			},
			{
				CallbackType.HTTPRequestDataReceived,
				typeof(HTTPRequestDataReceived_t)
			},
			{
				CallbackType.ScreenshotReady,
				typeof(ScreenshotReady_t)
			},
			{
				CallbackType.ScreenshotRequested,
				typeof(ScreenshotRequested_t)
			},
			{
				CallbackType.SteamUGCQueryCompleted,
				typeof(SteamUGCQueryCompleted_t)
			},
			{
				CallbackType.SteamUGCRequestUGCDetailsResult,
				typeof(SteamUGCRequestUGCDetailsResult_t)
			},
			{
				CallbackType.CreateItemResult,
				typeof(CreateItemResult_t)
			},
			{
				CallbackType.SubmitItemUpdateResult,
				typeof(SubmitItemUpdateResult_t)
			},
			{
				CallbackType.ItemInstalled,
				typeof(ItemInstalled_t)
			},
			{
				CallbackType.DownloadItemResult,
				typeof(DownloadItemResult_t)
			},
			{
				CallbackType.UserFavoriteItemsListChanged,
				typeof(UserFavoriteItemsListChanged_t)
			},
			{
				CallbackType.SetUserItemVoteResult,
				typeof(SetUserItemVoteResult_t)
			},
			{
				CallbackType.GetUserItemVoteResult,
				typeof(GetUserItemVoteResult_t)
			},
			{
				CallbackType.StartPlaytimeTrackingResult,
				typeof(StartPlaytimeTrackingResult_t)
			},
			{
				CallbackType.StopPlaytimeTrackingResult,
				typeof(StopPlaytimeTrackingResult_t)
			},
			{
				CallbackType.AddUGCDependencyResult,
				typeof(AddUGCDependencyResult_t)
			},
			{
				CallbackType.RemoveUGCDependencyResult,
				typeof(RemoveUGCDependencyResult_t)
			},
			{
				CallbackType.AddAppDependencyResult,
				typeof(AddAppDependencyResult_t)
			},
			{
				CallbackType.RemoveAppDependencyResult,
				typeof(RemoveAppDependencyResult_t)
			},
			{
				CallbackType.GetAppDependenciesResult,
				typeof(GetAppDependenciesResult_t)
			},
			{
				CallbackType.DeleteItemResult,
				typeof(DeleteItemResult_t)
			},
			{
				CallbackType.SteamAppInstalled,
				typeof(SteamAppInstalled_t)
			},
			{
				CallbackType.SteamAppUninstalled,
				typeof(SteamAppUninstalled_t)
			},
			{
				CallbackType.PlaybackStatusHasChanged,
				typeof(PlaybackStatusHasChanged_t)
			},
			{
				CallbackType.VolumeHasChanged,
				typeof(VolumeHasChanged_t)
			},
			{
				CallbackType.MusicPlayerWantsVolume,
				typeof(MusicPlayerWantsVolume_t)
			},
			{
				CallbackType.MusicPlayerSelectsQueueEntry,
				typeof(MusicPlayerSelectsQueueEntry_t)
			},
			{
				CallbackType.MusicPlayerSelectsPlaylistEntry,
				typeof(MusicPlayerSelectsPlaylistEntry_t)
			},
			{
				CallbackType.MusicPlayerRemoteWillActivate,
				typeof(MusicPlayerRemoteWillActivate_t)
			},
			{
				CallbackType.MusicPlayerRemoteWillDeactivate,
				typeof(MusicPlayerRemoteWillDeactivate_t)
			},
			{
				CallbackType.MusicPlayerRemoteToFront,
				typeof(MusicPlayerRemoteToFront_t)
			},
			{
				CallbackType.MusicPlayerWillQuit,
				typeof(MusicPlayerWillQuit_t)
			},
			{
				CallbackType.MusicPlayerWantsPlay,
				typeof(MusicPlayerWantsPlay_t)
			},
			{
				CallbackType.MusicPlayerWantsPause,
				typeof(MusicPlayerWantsPause_t)
			},
			{
				CallbackType.MusicPlayerWantsPlayPrevious,
				typeof(MusicPlayerWantsPlayPrevious_t)
			},
			{
				CallbackType.MusicPlayerWantsPlayNext,
				typeof(MusicPlayerWantsPlayNext_t)
			},
			{
				CallbackType.MusicPlayerWantsShuffled,
				typeof(MusicPlayerWantsShuffled_t)
			},
			{
				CallbackType.MusicPlayerWantsLooped,
				typeof(MusicPlayerWantsLooped_t)
			},
			{
				CallbackType.MusicPlayerWantsPlayingRepeatStatus,
				typeof(MusicPlayerWantsPlayingRepeatStatus_t)
			},
			{
				CallbackType.HTML_BrowserReady,
				typeof(HTML_BrowserReady_t)
			},
			{
				CallbackType.HTML_NeedsPaint,
				typeof(HTML_NeedsPaint_t)
			},
			{
				CallbackType.HTML_StartRequest,
				typeof(HTML_StartRequest_t)
			},
			{
				CallbackType.HTML_CloseBrowser,
				typeof(HTML_CloseBrowser_t)
			},
			{
				CallbackType.HTML_URLChanged,
				typeof(HTML_URLChanged_t)
			},
			{
				CallbackType.HTML_FinishedRequest,
				typeof(HTML_FinishedRequest_t)
			},
			{
				CallbackType.HTML_OpenLinkInNewTab,
				typeof(HTML_OpenLinkInNewTab_t)
			},
			{
				CallbackType.HTML_ChangedTitle,
				typeof(HTML_ChangedTitle_t)
			},
			{
				CallbackType.HTML_SearchResults,
				typeof(HTML_SearchResults_t)
			},
			{
				CallbackType.HTML_CanGoBackAndForward,
				typeof(HTML_CanGoBackAndForward_t)
			},
			{
				CallbackType.HTML_HorizontalScroll,
				typeof(HTML_HorizontalScroll_t)
			},
			{
				CallbackType.HTML_VerticalScroll,
				typeof(HTML_VerticalScroll_t)
			},
			{
				CallbackType.HTML_LinkAtPosition,
				typeof(HTML_LinkAtPosition_t)
			},
			{
				CallbackType.HTML_JSAlert,
				typeof(HTML_JSAlert_t)
			},
			{
				CallbackType.HTML_JSConfirm,
				typeof(HTML_JSConfirm_t)
			},
			{
				CallbackType.HTML_FileOpenDialog,
				typeof(HTML_FileOpenDialog_t)
			},
			{
				CallbackType.HTML_NewWindow,
				typeof(HTML_NewWindow_t)
			},
			{
				CallbackType.HTML_SetCursor,
				typeof(HTML_SetCursor_t)
			},
			{
				CallbackType.HTML_StatusText,
				typeof(HTML_StatusText_t)
			},
			{
				CallbackType.HTML_ShowToolTip,
				typeof(HTML_ShowToolTip_t)
			},
			{
				CallbackType.HTML_UpdateToolTip,
				typeof(HTML_UpdateToolTip_t)
			},
			{
				CallbackType.HTML_HideToolTip,
				typeof(HTML_HideToolTip_t)
			},
			{
				CallbackType.HTML_BrowserRestarted,
				typeof(HTML_BrowserRestarted_t)
			},
			{
				CallbackType.BroadcastUploadStart,
				typeof(BroadcastUploadStart_t)
			},
			{
				CallbackType.BroadcastUploadStop,
				typeof(BroadcastUploadStop_t)
			},
			{
				CallbackType.GetVideoURLResult,
				typeof(GetVideoURLResult_t)
			},
			{
				CallbackType.GetOPFSettingsResult,
				typeof(GetOPFSettingsResult_t)
			},
			{
				CallbackType.SteamInventoryResultReady,
				typeof(SteamInventoryResultReady_t)
			},
			{
				CallbackType.SteamInventoryFullUpdate,
				typeof(SteamInventoryFullUpdate_t)
			},
			{
				CallbackType.SteamInventoryDefinitionUpdate,
				typeof(SteamInventoryDefinitionUpdate_t)
			},
			{
				CallbackType.SteamInventoryEligiblePromoItemDefIDs,
				typeof(SteamInventoryEligiblePromoItemDefIDs_t)
			},
			{
				CallbackType.SteamInventoryStartPurchaseResult,
				typeof(SteamInventoryStartPurchaseResult_t)
			},
			{
				CallbackType.SteamInventoryRequestPricesResult,
				typeof(SteamInventoryRequestPricesResult_t)
			},
			{
				CallbackType.SteamParentalSettingsChanged,
				typeof(SteamParentalSettingsChanged_t)
			},
			{
				CallbackType.SearchForGameProgressCallback,
				typeof(SearchForGameProgressCallback_t)
			},
			{
				CallbackType.SearchForGameResultCallback,
				typeof(SearchForGameResultCallback_t)
			},
			{
				CallbackType.RequestPlayersForGameProgressCallback,
				typeof(RequestPlayersForGameProgressCallback_t)
			},
			{
				CallbackType.RequestPlayersForGameResultCallback,
				typeof(RequestPlayersForGameResultCallback_t)
			},
			{
				CallbackType.RequestPlayersForGameFinalResultCallback,
				typeof(RequestPlayersForGameFinalResultCallback_t)
			},
			{
				CallbackType.SubmitPlayerResultResultCallback,
				typeof(SubmitPlayerResultResultCallback_t)
			},
			{
				CallbackType.EndGameResultCallback,
				typeof(EndGameResultCallback_t)
			},
			{
				CallbackType.JoinPartyCallback,
				typeof(JoinPartyCallback_t)
			},
			{
				CallbackType.CreateBeaconCallback,
				typeof(CreateBeaconCallback_t)
			},
			{
				CallbackType.ReservationNotificationCallback,
				typeof(ReservationNotificationCallback_t)
			},
			{
				CallbackType.ChangeNumOpenSlotsCallback,
				typeof(ChangeNumOpenSlotsCallback_t)
			},
			{
				CallbackType.AvailableBeaconLocationsUpdated,
				typeof(AvailableBeaconLocationsUpdated_t)
			},
			{
				CallbackType.ActiveBeaconsUpdated,
				typeof(ActiveBeaconsUpdated_t)
			},
			{
				CallbackType.SteamRemotePlaySessionConnected,
				typeof(SteamRemotePlaySessionConnected_t)
			},
			{
				CallbackType.SteamRemotePlaySessionDisconnected,
				typeof(SteamRemotePlaySessionDisconnected_t)
			}
		};
	}
	internal class ISteamAppList : SteamInterface
	{
		internal ISteamAppList(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamAppList_v001();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamAppList_v001();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamAppList_GetNumInstalledApps")]
		private static extern uint _GetNumInstalledApps(IntPtr self);

		internal uint GetNumInstalledApps()
		{
			return _GetNumInstalledApps(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamAppList_GetInstalledApps")]
		private static extern uint _GetInstalledApps(IntPtr self, [In][Out] AppId[] pvecAppID, uint unMaxAppIDs);

		internal uint GetInstalledApps([In][Out] AppId[] pvecAppID, uint unMaxAppIDs)
		{
			return _GetInstalledApps(Self, pvecAppID, unMaxAppIDs);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamAppList_GetAppName")]
		private static extern int _GetAppName(IntPtr self, AppId nAppID, IntPtr pchName, int cchNameMax);

		internal int GetAppName(AppId nAppID, out string pchName)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			int result = _GetAppName(Self, nAppID, intPtr, 32768);
			pchName = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamAppList_GetAppInstallDir")]
		private static extern int _GetAppInstallDir(IntPtr self, AppId nAppID, IntPtr pchDirectory, int cchNameMax);

		internal int GetAppInstallDir(AppId nAppID, out string pchDirectory)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			int result = _GetAppInstallDir(Self, nAppID, intPtr, 32768);
			pchDirectory = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamAppList_GetAppBuildId")]
		private static extern int _GetAppBuildId(IntPtr self, AppId nAppID);

		internal int GetAppBuildId(AppId nAppID)
		{
			return _GetAppBuildId(Self, nAppID);
		}
	}
	internal class ISteamApps : SteamInterface
	{
		internal ISteamApps(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamApps_v008();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamApps_v008();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamGameServerApps_v008();

		public override IntPtr GetServerInterfacePointer()
		{
			return SteamAPI_SteamGameServerApps_v008();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsSubscribed")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsSubscribed(IntPtr self);

		internal bool BIsSubscribed()
		{
			return _BIsSubscribed(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsLowViolence")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsLowViolence(IntPtr self);

		internal bool BIsLowViolence()
		{
			return _BIsLowViolence(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsCybercafe")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsCybercafe(IntPtr self);

		internal bool BIsCybercafe()
		{
			return _BIsCybercafe(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsVACBanned")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsVACBanned(IntPtr self);

		internal bool BIsVACBanned()
		{
			return _BIsVACBanned(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetCurrentGameLanguage")]
		private static extern Utf8StringPointer _GetCurrentGameLanguage(IntPtr self);

		internal string GetCurrentGameLanguage()
		{
			return _GetCurrentGameLanguage(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetAvailableGameLanguages")]
		private static extern Utf8StringPointer _GetAvailableGameLanguages(IntPtr self);

		internal string GetAvailableGameLanguages()
		{
			return _GetAvailableGameLanguages(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsSubscribedApp")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsSubscribedApp(IntPtr self, AppId appID);

		internal bool BIsSubscribedApp(AppId appID)
		{
			return _BIsSubscribedApp(Self, appID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsDlcInstalled")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsDlcInstalled(IntPtr self, AppId appID);

		internal bool BIsDlcInstalled(AppId appID)
		{
			return _BIsDlcInstalled(Self, appID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetEarliestPurchaseUnixTime")]
		private static extern uint _GetEarliestPurchaseUnixTime(IntPtr self, AppId nAppID);

		internal uint GetEarliestPurchaseUnixTime(AppId nAppID)
		{
			return _GetEarliestPurchaseUnixTime(Self, nAppID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsSubscribedFromFreeWeekend")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsSubscribedFromFreeWeekend(IntPtr self);

		internal bool BIsSubscribedFromFreeWeekend()
		{
			return _BIsSubscribedFromFreeWeekend(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetDLCCount")]
		private static extern int _GetDLCCount(IntPtr self);

		internal int GetDLCCount()
		{
			return _GetDLCCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BGetDLCDataByIndex")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BGetDLCDataByIndex(IntPtr self, int iDLC, ref AppId pAppID, [MarshalAs(UnmanagedType.U1)] ref bool pbAvailable, IntPtr pchName, int cchNameBufferSize);

		internal bool BGetDLCDataByIndex(int iDLC, ref AppId pAppID, [MarshalAs(UnmanagedType.U1)] ref bool pbAvailable, out string pchName)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _BGetDLCDataByIndex(Self, iDLC, ref pAppID, ref pbAvailable, intPtr, 32768);
			pchName = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_InstallDLC")]
		private static extern void _InstallDLC(IntPtr self, AppId nAppID);

		internal void InstallDLC(AppId nAppID)
		{
			_InstallDLC(Self, nAppID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_UninstallDLC")]
		private static extern void _UninstallDLC(IntPtr self, AppId nAppID);

		internal void UninstallDLC(AppId nAppID)
		{
			_UninstallDLC(Self, nAppID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_RequestAppProofOfPurchaseKey")]
		private static extern void _RequestAppProofOfPurchaseKey(IntPtr self, AppId nAppID);

		internal void RequestAppProofOfPurchaseKey(AppId nAppID)
		{
			_RequestAppProofOfPurchaseKey(Self, nAppID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetCurrentBetaName")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetCurrentBetaName(IntPtr self, IntPtr pchName, int cchNameBufferSize);

		internal bool GetCurrentBetaName(out string pchName)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _GetCurrentBetaName(Self, intPtr, 32768);
			pchName = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_MarkContentCorrupt")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _MarkContentCorrupt(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bMissingFilesOnly);

		internal bool MarkContentCorrupt([MarshalAs(UnmanagedType.U1)] bool bMissingFilesOnly)
		{
			return _MarkContentCorrupt(Self, bMissingFilesOnly);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetInstalledDepots")]
		private static extern uint _GetInstalledDepots(IntPtr self, AppId appID, [In][Out] DepotId_t[] pvecDepots, uint cMaxDepots);

		internal uint GetInstalledDepots(AppId appID, [In][Out] DepotId_t[] pvecDepots, uint cMaxDepots)
		{
			return _GetInstalledDepots(Self, appID, pvecDepots, cMaxDepots);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetAppInstallDir")]
		private static extern uint _GetAppInstallDir(IntPtr self, AppId appID, IntPtr pchFolder, uint cchFolderBufferSize);

		internal uint GetAppInstallDir(AppId appID, out string pchFolder)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			uint result = _GetAppInstallDir(Self, appID, intPtr, 32768u);
			pchFolder = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsAppInstalled")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsAppInstalled(IntPtr self, AppId appID);

		internal bool BIsAppInstalled(AppId appID)
		{
			return _BIsAppInstalled(Self, appID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetAppOwner")]
		private static extern SteamId _GetAppOwner(IntPtr self);

		internal SteamId GetAppOwner()
		{
			return _GetAppOwner(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetLaunchQueryParam")]
		private static extern Utf8StringPointer _GetLaunchQueryParam(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey);

		internal string GetLaunchQueryParam([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey)
		{
			return _GetLaunchQueryParam(Self, pchKey);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetDlcDownloadProgress")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetDlcDownloadProgress(IntPtr self, AppId nAppID, ref ulong punBytesDownloaded, ref ulong punBytesTotal);

		internal bool GetDlcDownloadProgress(AppId nAppID, ref ulong punBytesDownloaded, ref ulong punBytesTotal)
		{
			return _GetDlcDownloadProgress(Self, nAppID, ref punBytesDownloaded, ref punBytesTotal);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetAppBuildId")]
		private static extern int _GetAppBuildId(IntPtr self);

		internal int GetAppBuildId()
		{
			return _GetAppBuildId(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_RequestAllProofOfPurchaseKeys")]
		private static extern void _RequestAllProofOfPurchaseKeys(IntPtr self);

		internal void RequestAllProofOfPurchaseKeys()
		{
			_RequestAllProofOfPurchaseKeys(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetFileDetails")]
		private static extern SteamAPICall_t _GetFileDetails(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszFileName);

		internal CallResult<FileDetailsResult_t> GetFileDetails([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszFileName)
		{
			return new CallResult<FileDetailsResult_t>(_GetFileDetails(Self, pszFileName), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetLaunchCommandLine")]
		private static extern int _GetLaunchCommandLine(IntPtr self, IntPtr pszCommandLine, int cubCommandLine);

		internal int GetLaunchCommandLine(out string pszCommandLine)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			int result = _GetLaunchCommandLine(Self, intPtr, 32768);
			pszCommandLine = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsSubscribedFromFamilySharing")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsSubscribedFromFamilySharing(IntPtr self);

		internal bool BIsSubscribedFromFamilySharing()
		{
			return _BIsSubscribedFromFamilySharing(Self);
		}
	}
	internal class ISteamClient : SteamInterface
	{
		internal ISteamClient(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_CreateSteamPipe")]
		private static extern HSteamPipe _CreateSteamPipe(IntPtr self);

		internal HSteamPipe CreateSteamPipe()
		{
			return _CreateSteamPipe(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_BReleaseSteamPipe")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BReleaseSteamPipe(IntPtr self, HSteamPipe hSteamPipe);

		internal bool BReleaseSteamPipe(HSteamPipe hSteamPipe)
		{
			return _BReleaseSteamPipe(Self, hSteamPipe);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_ConnectToGlobalUser")]
		private static extern HSteamUser _ConnectToGlobalUser(IntPtr self, HSteamPipe hSteamPipe);

		internal HSteamUser ConnectToGlobalUser(HSteamPipe hSteamPipe)
		{
			return _ConnectToGlobalUser(Self, hSteamPipe);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_CreateLocalUser")]
		private static extern HSteamUser _CreateLocalUser(IntPtr self, ref HSteamPipe phSteamPipe, AccountType eAccountType);

		internal HSteamUser CreateLocalUser(ref HSteamPipe phSteamPipe, AccountType eAccountType)
		{
			return _CreateLocalUser(Self, ref phSteamPipe, eAccountType);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_ReleaseUser")]
		private static extern void _ReleaseUser(IntPtr self, HSteamPipe hSteamPipe, HSteamUser hUser);

		internal void ReleaseUser(HSteamPipe hSteamPipe, HSteamUser hUser)
		{
			_ReleaseUser(Self, hSteamPipe, hUser);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamUser")]
		private static extern IntPtr _GetISteamUser(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamUser(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamUser(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamGameServer")]
		private static extern IntPtr _GetISteamGameServer(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamGameServer(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamGameServer(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_SetLocalIPBinding")]
		private static extern void _SetLocalIPBinding(IntPtr self, ref SteamIPAddress unIP, ushort usPort);

		internal void SetLocalIPBinding(ref SteamIPAddress unIP, ushort usPort)
		{
			_SetLocalIPBinding(Self, ref unIP, usPort);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamFriends")]
		private static extern IntPtr _GetISteamFriends(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamFriends(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamFriends(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamUtils")]
		private static extern IntPtr _GetISteamUtils(IntPtr self, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamUtils(HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamUtils(Self, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamMatchmaking")]
		private static extern IntPtr _GetISteamMatchmaking(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamMatchmaking(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamMatchmaking(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamMatchmakingServers")]
		private static extern IntPtr _GetISteamMatchmakingServers(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamMatchmakingServers(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamMatchmakingServers(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamGenericInterface")]
		private static extern IntPtr _GetISteamGenericInterface(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamGenericInterface(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamGenericInterface(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamUserStats")]
		private static extern IntPtr _GetISteamUserStats(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamUserStats(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamUserStats(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamGameServerStats")]
		private static extern IntPtr _GetISteamGameServerStats(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamGameServerStats(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamGameServerStats(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamApps")]
		private static extern IntPtr _GetISteamApps(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamApps(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamApps(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamNetworking")]
		private static extern IntPtr _GetISteamNetworking(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamNetworking(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamNetworking(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamRemoteStorage")]
		private static extern IntPtr _GetISteamRemoteStorage(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamRemoteStorage(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamRemoteStorage(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamScreenshots")]
		private static extern IntPtr _GetISteamScreenshots(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamScreenshots(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamScreenshots(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamGameSearch")]
		private static extern IntPtr _GetISteamGameSearch(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamGameSearch(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamGameSearch(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetIPCCallCount")]
		private static extern uint _GetIPCCallCount(IntPtr self);

		internal uint GetIPCCallCount()
		{
			return _GetIPCCallCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_SetWarningMessageHook")]
		private static extern void _SetWarningMessageHook(IntPtr self, IntPtr pFunction);

		internal void SetWarningMessageHook(IntPtr pFunction)
		{
			_SetWarningMessageHook(Self, pFunction);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_BShutdownIfAllPipesClosed")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BShutdownIfAllPipesClosed(IntPtr self);

		internal bool BShutdownIfAllPipesClosed()
		{
			return _BShutdownIfAllPipesClosed(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamHTTP")]
		private static extern IntPtr _GetISteamHTTP(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamHTTP(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamHTTP(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamController")]
		private static extern IntPtr _GetISteamController(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamController(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamController(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamUGC")]
		private static extern IntPtr _GetISteamUGC(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamUGC(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamUGC(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamAppList")]
		private static extern IntPtr _GetISteamAppList(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamAppList(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamAppList(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamMusic")]
		private static extern IntPtr _GetISteamMusic(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamMusic(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamMusic(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamMusicRemote")]
		private static extern IntPtr _GetISteamMusicRemote(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamMusicRemote(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamMusicRemote(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamHTMLSurface")]
		private static extern IntPtr _GetISteamHTMLSurface(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamHTMLSurface(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamHTMLSurface(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamInventory")]
		private static extern IntPtr _GetISteamInventory(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamInventory(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamInventory(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamVideo")]
		private static extern IntPtr _GetISteamVideo(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamVideo(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamVideo(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamParentalSettings")]
		private static extern IntPtr _GetISteamParentalSettings(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamParentalSettings(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamParentalSettings(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamInput")]
		private static extern IntPtr _GetISteamInput(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamInput(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamInput(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamParties")]
		private static extern IntPtr _GetISteamParties(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamParties(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamParties(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamRemotePlay")]
		private static extern IntPtr _GetISteamRemotePlay(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamRemotePlay(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamRemotePlay(Self, hSteamUser, hSteamPipe, pchVersion);
		}
	}
	internal class ISteamController : SteamInterface
	{
		internal ISteamController(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamController_v007();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamController_v007();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_Init")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _Init(IntPtr self);

		internal bool Init()
		{
			return _Init(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_Shutdown")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _Shutdown(IntPtr self);

		internal bool Shutdown()
		{
			return _Shutdown(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_RunFrame")]
		private static extern void _RunFrame(IntPtr self);

		internal void RunFrame()
		{
			_RunFrame(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetConnectedControllers")]
		private static extern int _GetConnectedControllers(IntPtr self, [In][Out] ControllerHandle_t[] handlesOut);

		internal int GetConnectedControllers([In][Out] ControllerHandle_t[] handlesOut)
		{
			return _GetConnectedControllers(Self, handlesOut);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetActionSetHandle")]
		private static extern ControllerActionSetHandle_t _GetActionSetHandle(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionSetName);

		internal ControllerActionSetHandle_t GetActionSetHandle([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionSetName)
		{
			return _GetActionSetHandle(Self, pszActionSetName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_ActivateActionSet")]
		private static extern void _ActivateActionSet(IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle);

		internal void ActivateActionSet(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle)
		{
			_ActivateActionSet(Self, controllerHandle, actionSetHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetCurrentActionSet")]
		private static extern ControllerActionSetHandle_t _GetCurrentActionSet(IntPtr self, ControllerHandle_t controllerHandle);

		internal ControllerActionSetHandle_t GetCurrentActionSet(ControllerHandle_t controllerHandle)
		{
			return _GetCurrentActionSet(Self, controllerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_ActivateActionSetLayer")]
		private static extern void _ActivateActionSetLayer(IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle);

		internal void ActivateActionSetLayer(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle)
		{
			_ActivateActionSetLayer(Self, controllerHandle, actionSetLayerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_DeactivateActionSetLayer")]
		private static extern void _DeactivateActionSetLayer(IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle);

		internal void DeactivateActionSetLayer(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle)
		{
			_DeactivateActionSetLayer(Self, controllerHandle, actionSetLayerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_DeactivateAllActionSetLayers")]
		private static extern void _DeactivateAllActionSetLayers(IntPtr self, ControllerHandle_t controllerHandle);

		internal void DeactivateAllActionSetLayers(ControllerHandle_t controllerHandle)
		{
			_DeactivateAllActionSetLayers(Self, controllerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetActiveActionSetLayers")]
		private static extern int _GetActiveActionSetLayers(IntPtr self, ControllerHandle_t controllerHandle, [In][Out] ControllerActionSetHandle_t[] handlesOut);

		internal int GetActiveActionSetLayers(ControllerHandle_t controllerHandle, [In][Out] ControllerActionSetHandle_t[] handlesOut)
		{
			return _GetActiveActionSetLayers(Self, controllerHandle, handlesOut);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetDigitalActionHandle")]
		private static extern ControllerDigitalActionHandle_t _GetDigitalActionHandle(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionName);

		internal ControllerDigitalActionHandle_t GetDigitalActionHandle([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionName)
		{
			return _GetDigitalActionHandle(Self, pszActionName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetDigitalActionData")]
		private static extern DigitalState _GetDigitalActionData(IntPtr self, ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle);

		internal DigitalState GetDigitalActionData(ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle)
		{
			return _GetDigitalActionData(Self, controllerHandle, digitalActionHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetDigitalActionOrigins")]
		private static extern int _GetDigitalActionOrigins(IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, ref ControllerActionOrigin originsOut);

		internal int GetDigitalActionOrigins(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, ref ControllerActionOrigin originsOut)
		{
			return _GetDigitalActionOrigins(Self, controllerHandle, actionSetHandle, digitalActionHandle, ref originsOut);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetAnalogActionHandle")]
		private static extern ControllerAnalogActionHandle_t _GetAnalogActionHandle(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionName);

		internal ControllerAnalogActionHandle_t GetAnalogActionHandle([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionName)
		{
			return _GetAnalogActionHandle(Self, pszActionName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetAnalogActionData")]
		private static extern AnalogState _GetAnalogActionData(IntPtr self, ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle);

		internal AnalogState GetAnalogActionData(ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle)
		{
			return _GetAnalogActionData(Self, controllerHandle, analogActionHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetAnalogActionOrigins")]
		private static extern int _GetAnalogActionOrigins(IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, ref ControllerActionOrigin originsOut);

		internal int GetAnalogActionOrigins(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, ref ControllerActionOrigin originsOut)
		{
			return _GetAnalogActionOrigins(Self, controllerHandle, actionSetHandle, analogActionHandle, ref originsOut);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetGlyphForActionOrigin")]
		private static extern Utf8StringPointer _GetGlyphForActionOrigin(IntPtr self, ControllerActionOrigin eOrigin);

		internal string GetGlyphForActionOrigin(ControllerActionOrigin eOrigin)
		{
			return _GetGlyphForActionOrigin(Self, eOrigin);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetStringForActionOrigin")]
		private static extern Utf8StringPointer _GetStringForActionOrigin(IntPtr self, ControllerActionOrigin eOrigin);

		internal string GetStringForActionOrigin(ControllerActionOrigin eOrigin)
		{
			return _GetStringForActionOrigin(Self, eOrigin);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_StopAnalogActionMomentum")]
		private static extern void _StopAnalogActionMomentum(IntPtr self, ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction);

		internal void StopAnalogActionMomentum(ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction)
		{
			_StopAnalogActionMomentum(Self, controllerHandle, eAction);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetMotionData")]
		private static extern MotionState _GetMotionData(IntPtr self, ControllerHandle_t controllerHandle);

		internal MotionState GetMotionData(ControllerHandle_t controllerHandle)
		{
			return _GetMotionData(Self, controllerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_TriggerHapticPulse")]
		private static extern void _TriggerHapticPulse(IntPtr self, ControllerHandle_t controllerHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec);

		internal void TriggerHapticPulse(ControllerHandle_t controllerHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec)
		{
			_TriggerHapticPulse(Self, controllerHandle, eTargetPad, usDurationMicroSec);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_TriggerRepeatedHapticPulse")]
		private static extern void _TriggerRepeatedHapticPulse(IntPtr self, ControllerHandle_t controllerHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec, ushort usOffMicroSec, ushort unRepeat, uint nFlags);

		internal void TriggerRepeatedHapticPulse(ControllerHandle_t controllerHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec, ushort usOffMicroSec, ushort unRepeat, uint nFlags)
		{
			_TriggerRepeatedHapticPulse(Self, controllerHandle, eTargetPad, usDurationMicroSec, usOffMicroSec, unRepeat, nFlags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_TriggerVibration")]
		private static extern void _TriggerVibration(IntPtr self, ControllerHandle_t controllerHandle, ushort usLeftSpeed, ushort usRightSpeed);

		internal void TriggerVibration(ControllerHandle_t controllerHandle, ushort usLeftSpeed, ushort usRightSpeed)
		{
			_TriggerVibration(Self, controllerHandle, usLeftSpeed, usRightSpeed);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_SetLEDColor")]
		private static extern void _SetLEDColor(IntPtr self, ControllerHandle_t controllerHandle, byte nColorR, byte nColorG, byte nColorB, uint nFlags);

		internal void SetLEDColor(ControllerHandle_t controllerHandle, byte nColorR, byte nColorG, byte nColorB, uint nFlags)
		{
			_SetLEDColor(Self, controllerHandle, nColorR, nColorG, nColorB, nFlags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_ShowBindingPanel")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ShowBindingPanel(IntPtr self, ControllerHandle_t controllerHandle);

		internal bool ShowBindingPanel(ControllerHandle_t controllerHandle)
		{
			return _ShowBindingPanel(Self, controllerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetInputTypeForHandle")]
		private static extern InputType _GetInputTypeForHandle(IntPtr self, ControllerHandle_t controllerHandle);

		internal InputType GetInputTypeForHandle(ControllerHandle_t controllerHandle)
		{
			return _GetInputTypeForHandle(Self, controllerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetControllerForGamepadIndex")]
		private static extern ControllerHandle_t _GetControllerForGamepadIndex(IntPtr self, int nIndex);

		internal ControllerHandle_t GetControllerForGamepadIndex(int nIndex)
		{
			return _GetControllerForGamepadIndex(Self, nIndex);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetGamepadIndexForController")]
		private static extern int _GetGamepadIndexForController(IntPtr self, ControllerHandle_t ulControllerHandle);

		internal int GetGamepadIndexForController(ControllerHandle_t ulControllerHandle)
		{
			return _GetGamepadIndexForController(Self, ulControllerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetStringForXboxOrigin")]
		private static extern Utf8StringPointer _GetStringForXboxOrigin(IntPtr self, XboxOrigin eOrigin);

		internal string GetStringForXboxOrigin(XboxOrigin eOrigin)
		{
			return _GetStringForXboxOrigin(Self, eOrigin);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetGlyphForXboxOrigin")]
		private static extern Utf8StringPointer _GetGlyphForXboxOrigin(IntPtr self, XboxOrigin eOrigin);

		internal string GetGlyphForXboxOrigin(XboxOrigin eOrigin)
		{
			return _GetGlyphForXboxOrigin(Self, eOrigin);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetActionOriginFromXboxOrigin")]
		private static extern ControllerActionOrigin _GetActionOriginFromXboxOrigin(IntPtr self, ControllerHandle_t controllerHandle, XboxOrigin eOrigin);

		internal ControllerActionOrigin GetActionOriginFromXboxOrigin(ControllerHandle_t controllerHandle, XboxOrigin eOrigin)
		{
			return _GetActionOriginFromXboxOrigin(Self, controllerHandle, eOrigin);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_TranslateActionOrigin")]
		private static extern ControllerActionOrigin _TranslateActionOrigin(IntPtr self, InputType eDestinationInputType, ControllerActionOrigin eSourceOrigin);

		internal ControllerActionOrigin TranslateActionOrigin(InputType eDestinationInputType, ControllerActionOrigin eSourceOrigin)
		{
			return _TranslateActionOrigin(Self, eDestinationInputType, eSourceOrigin);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetControllerBindingRevision")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetControllerBindingRevision(IntPtr self, ControllerHandle_t controllerHandle, ref int pMajor, ref int pMinor);

		internal bool GetControllerBindingRevision(ControllerHandle_t controllerHandle, ref int pMajor, ref int pMinor)
		{
			return _GetControllerBindingRevision(Self, controllerHandle, ref pMajor, ref pMinor);
		}
	}
	internal class ISteamFriends : SteamInterface
	{
		internal ISteamFriends(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamFriends_v017();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamFriends_v017();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetPersonaName")]
		private static extern Utf8StringPointer _GetPersonaName(IntPtr self);

		internal string GetPersonaName()
		{
			return _GetPersonaName(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_SetPersonaName")]
		private static extern SteamAPICall_t _SetPersonaName(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPersonaName);

		internal CallResult<SetPersonaNameResponse_t> SetPersonaName([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPersonaName)
		{
			return new CallResult<SetPersonaNameResponse_t>(_SetPersonaName(Self, pchPersonaName), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetPersonaState")]
		private static extern FriendState _GetPersonaState(IntPtr self);

		internal FriendState GetPersonaState()
		{
			return _GetPersonaState(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendCount")]
		private static extern int _GetFriendCount(IntPtr self, int iFriendFlags);

		internal int GetFriendCount(int iFriendFlags)
		{
			return _GetFriendCount(Self, iFriendFlags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendByIndex")]
		private static extern SteamId _GetFriendByIndex(IntPtr self, int iFriend, int iFriendFlags);

		internal SteamId GetFriendByIndex(int iFriend, int iFriendFlags)
		{
			return _GetFriendByIndex(Self, iFriend, iFriendFlags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendRelationship")]
		private static extern Relationship _GetFriendRelationship(IntPtr self, SteamId steamIDFriend);

		internal Relationship GetFriendRelationship(SteamId steamIDFriend)
		{
			return _GetFriendRelationship(Self, steamIDFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendPersonaState")]
		private static extern FriendState _GetFriendPersonaState(IntPtr self, SteamId steamIDFriend);

		internal FriendState GetFriendPersonaState(SteamId steamIDFriend)
		{
			return _GetFriendPersonaState(Self, steamIDFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendPersonaName")]
		private static extern Utf8StringPointer _GetFriendPersonaName(IntPtr self, SteamId steamIDFriend);

		internal string GetFriendPersonaName(SteamId steamIDFriend)
		{
			return _GetFriendPersonaName(Self, steamIDFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendGamePlayed")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetFriendGamePlayed(IntPtr self, SteamId steamIDFriend, ref FriendGameInfo_t pFriendGameInfo);

		internal bool GetFriendGamePlayed(SteamId steamIDFriend, ref FriendGameInfo_t pFriendGameInfo)
		{
			return _GetFriendGamePlayed(Self, steamIDFriend, ref pFriendGameInfo);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendPersonaNameHistory")]
		private static extern Utf8StringPointer _GetFriendPersonaNameHistory(IntPtr self, SteamId steamIDFriend, int iPersonaName);

		internal string GetFriendPersonaNameHistory(SteamId steamIDFriend, int iPersonaName)
		{
			return _GetFriendPersonaNameHistory(Self, steamIDFriend, iPersonaName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendSteamLevel")]
		private static extern int _GetFriendSteamLevel(IntPtr self, SteamId steamIDFriend);

		internal int GetFriendSteamLevel(SteamId steamIDFriend)
		{
			return _GetFriendSteamLevel(Self, steamIDFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetPlayerNickname")]
		private static extern Utf8StringPointer _GetPlayerNickname(IntPtr self, SteamId steamIDPlayer);

		internal string GetPlayerNickname(SteamId steamIDPlayer)
		{
			return _GetPlayerNickname(Self, steamIDPlayer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendsGroupCount")]
		private static extern int _GetFriendsGroupCount(IntPtr self);

		internal int GetFriendsGroupCount()
		{
			return _GetFriendsGroupCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendsGroupIDByIndex")]
		private static extern FriendsGroupID_t _GetFriendsGroupIDByIndex(IntPtr self, int iFG);

		internal FriendsGroupID_t GetFriendsGroupIDByIndex(int iFG)
		{
			return _GetFriendsGroupIDByIndex(Self, iFG);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendsGroupName")]
		private static extern Utf8StringPointer _GetFriendsGroupName(IntPtr self, FriendsGroupID_t friendsGroupID);

		internal string GetFriendsGroupName(FriendsGroupID_t friendsGroupID)
		{
			return _GetFriendsGroupName(Self, friendsGroupID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendsGroupMembersCount")]
		private static extern int _GetFriendsGroupMembersCount(IntPtr self, FriendsGroupID_t friendsGroupID);

		internal int GetFriendsGroupMembersCount(FriendsGroupID_t friendsGroupID)
		{
			return _GetFriendsGroupMembersCount(Self, friendsGroupID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendsGroupMembersList")]
		private static extern void _GetFriendsGroupMembersList(IntPtr self, FriendsGroupID_t friendsGroupID, [In][Out] SteamId[] pOutSteamIDMembers, int nMembersCount);

		internal void GetFriendsGroupMembersList(FriendsGroupID_t friendsGroupID, [In][Out] SteamId[] pOutSteamIDMembers, int nMembersCount)
		{
			_GetFriendsGroupMembersList(Self, friendsGroupID, pOutSteamIDMembers, nMembersCount);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_HasFriend")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _HasFriend(IntPtr self, SteamId steamIDFriend, int iFriendFlags);

		internal bool HasFriend(SteamId steamIDFriend, int iFriendFlags)
		{
			return _HasFriend(Self, steamIDFriend, iFriendFlags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanCount")]
		private static extern int _GetClanCount(IntPtr self);

		internal int GetClanCount()
		{
			return _GetClanCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanByIndex")]
		private static extern SteamId _GetClanByIndex(IntPtr self, int iClan);

		internal SteamId GetClanByIndex(int iClan)
		{
			return _GetClanByIndex(Self, iClan);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanName")]
		private static extern Utf8StringPointer _GetClanName(IntPtr self, SteamId steamIDClan);

		internal string GetClanName(SteamId steamIDClan)
		{
			return _GetClanName(Self, steamIDClan);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanTag")]
		private static extern Utf8StringPointer _GetClanTag(IntPtr self, SteamId steamIDClan);

		internal string GetClanTag(SteamId steamIDClan)
		{
			return _GetClanTag(Self, steamIDClan);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanActivityCounts")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetClanActivityCounts(IntPtr self, SteamId steamIDClan, ref int pnOnline, ref int pnInGame, ref int pnChatting);

		internal bool GetClanActivityCounts(SteamId steamIDClan, ref int pnOnline, ref int pnInGame, ref int pnChatting)
		{
			return _GetClanActivityCounts(Self, steamIDClan, ref pnOnline, ref pnInGame, ref pnChatting);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_DownloadClanActivityCounts")]
		private static extern SteamAPICall_t _DownloadClanActivityCounts(IntPtr self, [In][Out] SteamId[] psteamIDClans, int cClansToRequest);

		internal CallResult<DownloadClanActivityCountsResult_t> DownloadClanActivityCounts([In][Out] SteamId[] psteamIDClans, int cClansToRequest)
		{
			return new CallResult<DownloadClanActivityCountsResult_t>(_DownloadClanActivityCounts(Self, psteamIDClans, cClansToRequest), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendCountFromSource")]
		private static extern int _GetFriendCountFromSource(IntPtr self, SteamId steamIDSource);

		internal int GetFriendCountFromSource(SteamId steamIDSource)
		{
			return _GetFriendCountFromSource(Self, steamIDSource);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendFromSourceByIndex")]
		private static extern SteamId _GetFriendFromSourceByIndex(IntPtr self, SteamId steamIDSource, int iFriend);

		internal SteamId GetFriendFromSourceByIndex(SteamId steamIDSource, int iFriend)
		{
			return _GetFriendFromSourceByIndex(Self, steamIDSource, iFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_IsUserInSource")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsUserInSource(IntPtr self, SteamId steamIDUser, SteamId steamIDSource);

		internal bool IsUserInSource(SteamId steamIDUser, SteamId steamIDSource)
		{
			return _IsUserInSource(Self, steamIDUser, steamIDSource);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_SetInGameVoiceSpeaking")]
		private static extern void _SetInGameVoiceSpeaking(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.U1)] bool bSpeaking);

		internal void SetInGameVoiceSpeaking(SteamId steamIDUser, [MarshalAs(UnmanagedType.U1)] bool bSpeaking)
		{
			_SetInGameVoiceSpeaking(Self, steamIDUser, bSpeaking);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_ActivateGameOverlay")]
		private static extern void _ActivateGameOverlay(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchDialog);

		internal void ActivateGameOverlay([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchDialog)
		{
			_ActivateGameOverlay(Self, pchDialog);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_ActivateGameOverlayToUser")]
		private static extern void _ActivateGameOverlayToUser(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchDialog, SteamId steamID);

		internal void ActivateGameOverlayToUser([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchDialog, SteamId steamID)
		{
			_ActivateGameOverlayToUser(Self, pchDialog, steamID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage")]
		private static extern void _ActivateGameOverlayToWebPage(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchURL, ActivateGameOverlayToWebPageMode eMode);

		internal void ActivateGameOverlayToWebPage([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchURL, ActivateGameOverlayToWebPageMode eMode)
		{
			_ActivateGameOverlayToWebPage(Self, pchURL, eMode);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_ActivateGameOverlayToStore")]
		private static extern void _ActivateGameOverlayToStore(IntPtr self, AppId nAppID, OverlayToStoreFlag eFlag);

		internal void ActivateGameOverlayToStore(AppId nAppID, OverlayToStoreFlag eFlag)
		{
			_ActivateGameOverlayToStore(Self, nAppID, eFlag);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_SetPlayedWith")]
		private static extern void _SetPlayedWith(IntPtr self, SteamId steamIDUserPlayedWith);

		internal void SetPlayedWith(SteamId steamIDUserPlayedWith)
		{
			_SetPlayedWith(Self, steamIDUserPlayedWith);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialog")]
		private static extern void _ActivateGameOverlayInviteDialog(IntPtr self, SteamId steamIDLobby);

		internal void ActivateGameOverlayInviteDialog(SteamId steamIDLobby)
		{
			_ActivateGameOverlayInviteDialog(Self, steamIDLobby);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetSmallFriendAvatar")]
		private static extern int _GetSmallFriendAvatar(IntPtr self, SteamId steamIDFriend);

		internal int GetSmallFriendAvatar(SteamId steamIDFriend)
		{
			return _GetSmallFriendAvatar(Self, steamIDFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetMediumFriendAvatar")]
		private static extern int _GetMediumFriendAvatar(IntPtr self, SteamId steamIDFriend);

		internal int GetMediumFriendAvatar(SteamId steamIDFriend)
		{
			return _GetMediumFriendAvatar(Self, steamIDFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetLargeFriendAvatar")]
		private static extern int _GetLargeFriendAvatar(IntPtr self, SteamId steamIDFriend);

		internal int GetLargeFriendAvatar(SteamId steamIDFriend)
		{
			return _GetLargeFriendAvatar(Self, steamIDFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_RequestUserInformation")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _RequestUserInformation(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.U1)] bool bRequireNameOnly);

		internal bool RequestUserInformation(SteamId steamIDUser, [MarshalAs(UnmanagedType.U1)] bool bRequireNameOnly)
		{
			return _RequestUserInformation(Self, steamIDUser, bRequireNameOnly);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_RequestClanOfficerList")]
		private static extern SteamAPICall_t _RequestClanOfficerList(IntPtr self, SteamId steamIDClan);

		internal CallResult<ClanOfficerListResponse_t> RequestClanOfficerList(SteamId steamIDClan)
		{
			return new CallResult<ClanOfficerListResponse_t>(_RequestClanOfficerList(Self, steamIDClan), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanOwner")]
		private static extern SteamId _GetClanOwner(IntPtr self, SteamId steamIDClan);

		internal SteamId GetClanOwner(SteamId steamIDClan)
		{
			return _GetClanOwner(Self, steamIDClan);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanOfficerCount")]
		private static extern int _GetClanOfficerCount(IntPtr self, SteamId steamIDClan);

		internal int GetClanOfficerCount(SteamId steamIDClan)
		{
			return _GetClanOfficerCount(Self, steamIDClan);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanOfficerByIndex")]
		private static extern SteamId _GetClanOfficerByIndex(IntPtr self, SteamId steamIDClan, int iOfficer);

		internal SteamId GetClanOfficerByIndex(SteamId steamIDClan, int iOfficer)
		{
			return _GetClanOfficerByIndex(Self, steamIDClan, iOfficer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetUserRestrictions")]
		private static extern uint _GetUserRestrictions(IntPtr self);

		internal uint GetUserRestrictions()
		{
			return _GetUserRestrictions(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_SetRichPresence")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetRichPresence(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue);

		internal bool SetRichPresence([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue)
		{
			return _SetRichPresence(Self, pchKey, pchValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_ClearRichPresence")]
		private static extern void _ClearRichPresence(IntPtr self);

		internal void ClearRichPresence()
		{
			_ClearRichPresence(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendRichPresence")]
		private static extern Utf8StringPointer _GetFriendRichPresence(IntPtr self, SteamId steamIDFriend, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey);

		internal string GetFriendRichPresence(SteamId steamIDFriend, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey)
		{
			return _GetFriendRichPresence(Self, steamIDFriend, pchKey);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendRichPresenceKeyCount")]
		private static extern int _GetFriendRichPresenceKeyCount(IntPtr self, SteamId steamIDFriend);

		internal int GetFriendRichPresenceKeyCount(SteamId steamIDFriend)
		{
			return _GetFriendRichPresenceKeyCount(Self, steamIDFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendRichPresenceKeyByIndex")]
		private static extern Utf8StringPointer _GetFriendRichPresenceKeyByIndex(IntPtr self, SteamId steamIDFriend, int iKey);

		internal string GetFriendRichPresenceKeyByIndex(SteamId steamIDFriend, int iKey)
		{
			return _GetFriendRichPresenceKeyByIndex(Self, steamIDFriend, iKey);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_RequestFriendRichPresence")]
		private static extern void _RequestFriendRichPresence(IntPtr self, SteamId steamIDFriend);

		internal void RequestFriendRichPresence(SteamId steamIDFriend)
		{
			_RequestFriendRichPresence(Self, steamIDFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_InviteUserToGame")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _InviteUserToGame(IntPtr self, SteamId steamIDFriend, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchConnectString);

		internal bool InviteUserToGame(SteamId steamIDFriend, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchConnectString)
		{
			return _InviteUserToGame(Self, steamIDFriend, pchConnectString);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetCoplayFriendCount")]
		private static extern int _GetCoplayFriendCount(IntPtr self);

		internal int GetCoplayFriendCount()
		{
			return _GetCoplayFriendCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetCoplayFriend")]
		private static extern SteamId _GetCoplayFriend(IntPtr self, int iCoplayFriend);

		internal SteamId GetCoplayFriend(int iCoplayFriend)
		{
			return _GetCoplayFriend(Self, iCoplayFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendCoplayTime")]
		private static extern int _GetFriendCoplayTime(IntPtr self, SteamId steamIDFriend);

		internal int GetFriendCoplayTime(SteamId steamIDFriend)
		{
			return _GetFriendCoplayTime(Self, steamIDFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendCoplayGame")]
		private static extern AppId _GetFriendCoplayGame(IntPtr self, SteamId steamIDFriend);

		internal AppId GetFriendCoplayGame(SteamId steamIDFriend)
		{
			return _GetFriendCoplayGame(Self, steamIDFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_JoinClanChatRoom")]
		private static extern SteamAPICall_t _JoinClanChatRoom(IntPtr self, SteamId steamIDClan);

		internal CallResult<JoinClanChatRoomCompletionResult_t> JoinClanChatRoom(SteamId steamIDClan)
		{
			return new CallResult<JoinClanChatRoomCompletionResult_t>(_JoinClanChatRoom(Self, steamIDClan), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_LeaveClanChatRoom")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _LeaveClanChatRoom(IntPtr self, SteamId steamIDClan);

		internal bool LeaveClanChatRoom(SteamId steamIDClan)
		{
			return _LeaveClanChatRoom(Self, steamIDClan);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanChatMemberCount")]
		private static extern int _GetClanChatMemberCount(IntPtr self, SteamId steamIDClan);

		internal int GetClanChatMemberCount(SteamId steamIDClan)
		{
			return _GetClanChatMemberCount(Self, steamIDClan);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetChatMemberByIndex")]
		private static extern SteamId _GetChatMemberByIndex(IntPtr self, SteamId steamIDClan, int iUser);

		internal SteamId GetChatMemberByIndex(SteamId steamIDClan, int iUser)
		{
			return _GetChatMemberByIndex(Self, steamIDClan, iUser);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_SendClanChatMessage")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SendClanChatMessage(IntPtr self, SteamId steamIDClanChat, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchText);

		internal bool SendClanChatMessage(SteamId steamIDClanChat, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchText)
		{
			return _SendClanChatMessage(Self, steamIDClanChat, pchText);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanChatMessage")]
		private static extern int _GetClanChatMessage(IntPtr self, SteamId steamIDClanChat, int iMessage, IntPtr prgchText, int cchTextMax, ref ChatEntryType peChatEntryType, ref SteamId psteamidChatter);

		internal int GetClanChatMessage(SteamId steamIDClanChat, int iMessage, IntPtr prgchText, int cchTextMax, ref ChatEntryType peChatEntryType, ref SteamId psteamidChatter)
		{
			return _GetClanChatMessage(Self, steamIDClanChat, iMessage, prgchText, cchTextMax, ref peChatEntryType, ref psteamidChatter);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_IsClanChatAdmin")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsClanChatAdmin(IntPtr self, SteamId steamIDClanChat, SteamId steamIDUser);

		internal bool IsClanChatAdmin(SteamId steamIDClanChat, SteamId steamIDUser)
		{
			return _IsClanChatAdmin(Self, steamIDClanChat, steamIDUser);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_IsClanChatWindowOpenInSteam")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsClanChatWindowOpenInSteam(IntPtr self, SteamId steamIDClanChat);

		internal bool IsClanChatWindowOpenInSteam(SteamId steamIDClanChat)
		{
			return _IsClanChatWindowOpenInSteam(Self, steamIDClanChat);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_OpenClanChatWindowInSteam")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _OpenClanChatWindowInSteam(IntPtr self, SteamId steamIDClanChat);

		internal bool OpenClanChatWindowInSteam(SteamId steamIDClanChat)
		{
			return _OpenClanChatWindowInSteam(Self, steamIDClanChat);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_CloseClanChatWindowInSteam")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _CloseClanChatWindowInSteam(IntPtr self, SteamId steamIDClanChat);

		internal bool CloseClanChatWindowInSteam(SteamId steamIDClanChat)
		{
			return _CloseClanChatWindowInSteam(Self, steamIDClanChat);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_SetListenForFriendsMessages")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetListenForFriendsMessages(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bInterceptEnabled);

		internal bool SetListenForFriendsMessages([MarshalAs(UnmanagedType.U1)] bool bInterceptEnabled)
		{
			return _SetListenForFriendsMessages(Self, bInterceptEnabled);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_ReplyToFriendMessage")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ReplyToFriendMessage(IntPtr self, SteamId steamIDFriend, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchMsgToSend);

		internal bool ReplyToFriendMessage(SteamId steamIDFriend, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchMsgToSend)
		{
			return _ReplyToFriendMessage(Self, steamIDFriend, pchMsgToSend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendMessage")]
		private static extern int _GetFriendMessage(IntPtr self, SteamId steamIDFriend, int iMessageID, IntPtr pvData, int cubData, ref ChatEntryType peChatEntryType);

		internal int GetFriendMessage(SteamId steamIDFriend, int iMessageID, IntPtr pvData, int cubData, ref ChatEntryType peChatEntryType)
		{
			return _GetFriendMessage(Self, steamIDFriend, iMessageID, pvData, cubData, ref peChatEntryType);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFollowerCount")]
		private static extern SteamAPICall_t _GetFollowerCount(IntPtr self, SteamId steamID);

		internal CallResult<FriendsGetFollowerCount_t> GetFollowerCount(SteamId steamID)
		{
			return new CallResult<FriendsGetFollowerCount_t>(_GetFollowerCount(Self, steamID), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_IsFollowing")]
		private static extern SteamAPICall_t _IsFollowing(IntPtr self, SteamId steamID);

		internal CallResult<FriendsIsFollowing_t> IsFollowing(SteamId steamID)
		{
			return new CallResult<FriendsIsFollowing_t>(_IsFollowing(Self, steamID), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_EnumerateFollowingList")]
		private static extern SteamAPICall_t _EnumerateFollowingList(IntPtr self, uint unStartIndex);

		internal CallResult<FriendsEnumerateFollowingList_t> EnumerateFollowingList(uint unStartIndex)
		{
			return new CallResult<FriendsEnumerateFollowingList_t>(_EnumerateFollowingList(Self, unStartIndex), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_IsClanPublic")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsClanPublic(IntPtr self, SteamId steamIDClan);

		internal bool IsClanPublic(SteamId steamIDClan)
		{
			return _IsClanPublic(Self, steamIDClan);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_IsClanOfficialGameGroup")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsClanOfficialGameGroup(IntPtr self, SteamId steamIDClan);

		internal bool IsClanOfficialGameGroup(SteamId steamIDClan)
		{
			return _IsClanOfficialGameGroup(Self, steamIDClan);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetNumChatsWithUnreadPriorityMessages")]
		private static extern int _GetNumChatsWithUnreadPriorityMessages(IntPtr self);

		internal int GetNumChatsWithUnreadPriorityMessages()
		{
			return _GetNumChatsWithUnreadPriorityMessages(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_ActivateGameOverlayRemotePlayTogetherInviteDialog")]
		private static extern void _ActivateGameOverlayRemotePlayTogetherInviteDialog(IntPtr self, SteamId steamIDLobby);

		internal void ActivateGameOverlayRemotePlayTogetherInviteDialog(SteamId steamIDLobby)
		{
			_ActivateGameOverlayRemotePlayTogetherInviteDialog(Self, steamIDLobby);
		}
	}
	internal class ISteamGameSearch : SteamInterface
	{
		internal ISteamGameSearch(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamGameSearch_v001();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamGameSearch_v001();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameSearch_AddGameSearchParams")]
		private static extern GameSearchErrorCode_t _AddGameSearchParams(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKeyToFind, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValuesToFind);

		internal GameSearchErrorCode_t AddGameSearchParams([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKeyToFind, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValuesToFind)
		{
			return _AddGameSearchParams(Self, pchKeyToFind, pchValuesToFind);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameSearch_SearchForGameWithLobby")]
		private static extern GameSearchErrorCode_t _SearchForGameWithLobby(IntPtr self, SteamId steamIDLobby, int nPlayerMin, int nPlayerMax);

		internal GameSearchErrorCode_t SearchForGameWithLobby(SteamId steamIDLobby, int nPlayerMin, int nPlayerMax)
		{
			return _SearchForGameWithLobby(Self, steamIDLobby, nPlayerMin, nPlayerMax);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameSearch_SearchForGameSolo")]
		private static extern GameSearchErrorCode_t _SearchForGameSolo(IntPtr self, int nPlayerMin, int nPlayerMax);

		internal GameSearchErrorCode_t SearchForGameSolo(int nPlayerMin, int nPlayerMax)
		{
			return _SearchForGameSolo(Self, nPlayerMin, nPlayerMax);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameSearch_AcceptGame")]
		private static extern GameSearchErrorCode_t _AcceptGame(IntPtr self);

		internal GameSearchErrorCode_t AcceptGame()
		{
			return _AcceptGame(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameSearch_DeclineGame")]
		private static extern GameSearchErrorCode_t _DeclineGame(IntPtr self);

		internal GameSearchErrorCode_t DeclineGame()
		{
			return _DeclineGame(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameSearch_RetrieveConnectionDetails")]
		private static extern GameSearchErrorCode_t _RetrieveConnectionDetails(IntPtr self, SteamId steamIDHost, IntPtr pchConnectionDetails, int cubConnectionDetails);

		internal GameSearchErrorCode_t RetrieveConnectionDetails(SteamId steamIDHost, out string pchConnectionDetails)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			GameSearchErrorCode_t result = _RetrieveConnectionDetails(Self, steamIDHost, intPtr, 32768);
			pchConnectionDetails = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameSearch_EndGameSearch")]
		private static extern GameSearchErrorCode_t _EndGameSearch(IntPtr self);

		internal GameSearchErrorCode_t EndGameSearch()
		{
			return _EndGameSearch(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameSearch_SetGameHostParams")]
		private static extern GameSearchErrorCode_t _SetGameHostParams(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue);

		internal GameSearchErrorCode_t SetGameHostParams([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue)
		{
			return _SetGameHostParams(Self, pchKey, pchValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameSearch_SetConnectionDetails")]
		private static extern GameSearchErrorCode_t _SetConnectionDetails(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchConnectionDetails, int cubConnectionDetails);

		internal GameSearchErrorCode_t SetConnectionDetails([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchConnectionDetails, int cubConnectionDetails)
		{
			return _SetConnectionDetails(Self, pchConnectionDetails, cubConnectionDetails);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameSearch_RequestPlayersForGame")]
		private static extern GameSearchErrorCode_t _RequestPlayersForGame(IntPtr self, int nPlayerMin, int nPlayerMax, int nMaxTeamSize);

		internal GameSearchErrorCode_t RequestPlayersForGame(int nPlayerMin, int nPlayerMax, int nMaxTeamSize)
		{
			return _RequestPlayersForGame(Self, nPlayerMin, nPlayerMax, nMaxTeamSize);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameSearch_HostConfirmGameStart")]
		private static extern GameSearchErrorCode_t _HostConfirmGameStart(IntPtr self, ulong ullUniqueGameID);

		internal GameSearchErrorCode_t HostConfirmGameStart(ulong ullUniqueGameID)
		{
			return _HostConfirmGameStart(Self, ullUniqueGameID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameSearch_CancelRequestPlayersForGame")]
		private static extern GameSearchErrorCode_t _CancelRequestPlayersForGame(IntPtr self);

		internal GameSearchErrorCode_t CancelRequestPlayersForGame()
		{
			return _CancelRequestPlayersForGame(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameSearch_SubmitPlayerResult")]
		private static extern GameSearchErrorCode_t _SubmitPlayerResult(IntPtr self, ulong ullUniqueGameID, SteamId steamIDPlayer, PlayerResult_t EPlayerResult);

		internal GameSearchErrorCode_t SubmitPlayerResult(ulong ullUniqueGameID, SteamId steamIDPlayer, PlayerResult_t EPlayerResult)
		{
			return _SubmitPlayerResult(Self, ullUniqueGameID, steamIDPlayer, EPlayerResult);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameSearch_EndGame")]
		private static extern GameSearchErrorCode_t _EndGame(IntPtr self, ulong ullUniqueGameID);

		internal GameSearchErrorCode_t EndGame(ulong ullUniqueGameID)
		{
			return _EndGame(Self, ullUniqueGameID);
		}
	}
	internal class ISteamGameServer : SteamInterface
	{
		internal ISteamGameServer(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamGameServer_v013();

		public override IntPtr GetServerInterfacePointer()
		{
			return SteamAPI_SteamGameServer_v013();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetProduct")]
		private static extern void _SetProduct(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszProduct);

		internal void SetProduct([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszProduct)
		{
			_SetProduct(Self, pszProduct);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetGameDescription")]
		private static extern void _SetGameDescription(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszGameDescription);

		internal void SetGameDescription([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszGameDescription)
		{
			_SetGameDescription(Self, pszGameDescription);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetModDir")]
		private static extern void _SetModDir(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszModDir);

		internal void SetModDir([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszModDir)
		{
			_SetModDir(Self, pszModDir);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetDedicatedServer")]
		private static extern void _SetDedicatedServer(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bDedicated);

		internal void SetDedicatedServer([MarshalAs(UnmanagedType.U1)] bool bDedicated)
		{
			_SetDedicatedServer(Self, bDedicated);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_LogOn")]
		private static extern void _LogOn(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszToken);

		internal void LogOn([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszToken)
		{
			_LogOn(Self, pszToken);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_LogOnAnonymous")]
		private static extern void _LogOnAnonymous(IntPtr self);

		internal void LogOnAnonymous()
		{
			_LogOnAnonymous(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_LogOff")]
		private static extern void _LogOff(IntPtr self);

		internal void LogOff()
		{
			_LogOff(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_BLoggedOn")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BLoggedOn(IntPtr self);

		internal bool BLoggedOn()
		{
			return _BLoggedOn(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_BSecure")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BSecure(IntPtr self);

		internal bool BSecure()
		{
			return _BSecure(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_GetSteamID")]
		private static extern SteamId _GetSteamID(IntPtr self);

		internal SteamId GetSteamID()
		{
			return _GetSteamID(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_WasRestartRequested")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _WasRestartRequested(IntPtr self);

		internal bool WasRestartRequested()
		{
			return _WasRestartRequested(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetMaxPlayerCount")]
		private static extern void _SetMaxPlayerCount(IntPtr self, int cPlayersMax);

		internal void SetMaxPlayerCount(int cPlayersMax)
		{
			_SetMaxPlayerCount(Self, cPlayersMax);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetBotPlayerCount")]
		private static extern void _SetBotPlayerCount(IntPtr self, int cBotplayers);

		internal void SetBotPlayerCount(int cBotplayers)
		{
			_SetBotPlayerCount(Self, cBotplayers);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetServerName")]
		private static extern void _SetServerName(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszServerName);

		internal void SetServerName([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszServerName)
		{
			_SetServerName(Self, pszServerName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetMapName")]
		private static extern void _SetMapName(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszMapName);

		internal void SetMapName([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszMapName)
		{
			_SetMapName(Self, pszMapName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetPasswordProtected")]
		private static extern void _SetPasswordProtected(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bPasswordProtected);

		internal void SetPasswordProtected([MarshalAs(UnmanagedType.U1)] bool bPasswordProtected)
		{
			_SetPasswordProtected(Self, bPasswordProtected);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetSpectatorPort")]
		private static extern void _SetSpectatorPort(IntPtr self, ushort unSpectatorPort);

		internal void SetSpectatorPort(ushort unSpectatorPort)
		{
			_SetSpectatorPort(Self, unSpectatorPort);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetSpectatorServerName")]
		private static extern void _SetSpectatorServerName(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszSpectatorServerName);

		internal void SetSpectatorServerName([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszSpectatorServerName)
		{
			_SetSpectatorServerName(Self, pszSpectatorServerName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_ClearAllKeyValues")]
		private static extern void _ClearAllKeyValues(IntPtr self);

		internal void ClearAllKeyValues()
		{
			_ClearAllKeyValues(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetKeyValue")]
		private static extern void _SetKeyValue(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pValue);

		internal void SetKeyValue([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pValue)
		{
			_SetKeyValue(Self, pKey, pValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetGameTags")]
		private static extern void _SetGameTags(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchGameTags);

		internal void SetGameTags([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchGameTags)
		{
			_SetGameTags(Self, pchGameTags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetGameData")]
		private static extern void _SetGameData(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchGameData);

		internal void SetGameData([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchGameData)
		{
			_SetGameData(Self, pchGameData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetRegion")]
		private static extern void _SetRegion(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszRegion);

		internal void SetRegion([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszRegion)
		{
			_SetRegion(Self, pszRegion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SendUserConnectAndAuthenticate")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SendUserConnectAndAuthenticate(IntPtr self, uint unIPClient, IntPtr pvAuthBlob, uint cubAuthBlobSize, ref SteamId pSteamIDUser);

		internal bool SendUserConnectAndAuthenticate(uint unIPClient, IntPtr pvAuthBlob, uint cubAuthBlobSize, ref SteamId pSteamIDUser)
		{
			return _SendUserConnectAndAuthenticate(Self, unIPClient, pvAuthBlob, cubAuthBlobSize, ref pSteamIDUser);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_CreateUnauthenticatedUserConnection")]
		private static extern SteamId _CreateUnauthenticatedUserConnection(IntPtr self);

		internal SteamId CreateUnauthenticatedUserConnection()
		{
			return _CreateUnauthenticatedUserConnection(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SendUserDisconnect")]
		private static extern void _SendUserDisconnect(IntPtr self, SteamId steamIDUser);

		internal void SendUserDisconnect(SteamId steamIDUser)
		{
			_SendUserDisconnect(Self, steamIDUser);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_BUpdateUserData")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BUpdateUserData(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPlayerName, uint uScore);

		internal bool BUpdateUserData(SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPlayerName, uint uScore)
		{
			return _BUpdateUserData(Self, steamIDUser, pchPlayerName, uScore);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_GetAuthSessionTicket")]
		private static extern HAuthTicket _GetAuthSessionTicket(IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket);

		internal HAuthTicket GetAuthSessionTicket(IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket)
		{
			return _GetAuthSessionTicket(Self, pTicket, cbMaxTicket, ref pcbTicket);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_BeginAuthSession")]
		private static extern BeginAuthResult _BeginAuthSession(IntPtr self, IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID);

		internal BeginAuthResult BeginAuthSession(IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID)
		{
			return _BeginAuthSession(Self, pAuthTicket, cbAuthTicket, steamID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_EndAuthSession")]
		private static extern void _EndAuthSession(IntPtr self, SteamId steamID);

		internal void EndAuthSession(SteamId steamID)
		{
			_EndAuthSession(Self, steamID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_CancelAuthTicket")]
		private static extern void _CancelAuthTicket(IntPtr self, HAuthTicket hAuthTicket);

		internal void CancelAuthTicket(HAuthTicket hAuthTicket)
		{
			_CancelAuthTicket(Self, hAuthTicket);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_UserHasLicenseForApp")]
		private static extern UserHasLicenseForAppResult _UserHasLicenseForApp(IntPtr self, SteamId steamID, AppId appID);

		internal UserHasLicenseForAppResult UserHasLicenseForApp(SteamId steamID, AppId appID)
		{
			return _UserHasLicenseForApp(Self, steamID, appID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_RequestUserGroupStatus")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _RequestUserGroupStatus(IntPtr self, SteamId steamIDUser, SteamId steamIDGroup);

		internal bool RequestUserGroupStatus(SteamId steamIDUser, SteamId steamIDGroup)
		{
			return _RequestUserGroupStatus(Self, steamIDUser, steamIDGroup);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_GetGameplayStats")]
		private static extern void _GetGameplayStats(IntPtr self);

		internal void GetGameplayStats()
		{
			_GetGameplayStats(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_GetServerReputation")]
		private static extern SteamAPICall_t _GetServerReputation(IntPtr self);

		internal CallResult<GSReputation_t> GetServerReputation()
		{
			return new CallResult<GSReputation_t>(_GetServerReputation(Self), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_GetPublicIP")]
		private static extern SteamIPAddress _GetPublicIP(IntPtr self);

		internal SteamIPAddress GetPublicIP()
		{
			return _GetPublicIP(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_HandleIncomingPacket")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _HandleIncomingPacket(IntPtr self, IntPtr pData, int cbData, uint srcIP, ushort srcPort);

		internal bool HandleIncomingPacket(IntPtr pData, int cbData, uint srcIP, ushort srcPort)
		{
			return _HandleIncomingPacket(Self, pData, cbData, srcIP, srcPort);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_GetNextOutgoingPacket")]
		private static extern int _GetNextOutgoingPacket(IntPtr self, IntPtr pOut, int cbMaxOut, ref uint pNetAdr, ref ushort pPort);

		internal int GetNextOutgoingPacket(IntPtr pOut, int cbMaxOut, ref uint pNetAdr, ref ushort pPort)
		{
			return _GetNextOutgoingPacket(Self, pOut, cbMaxOut, ref pNetAdr, ref pPort);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_EnableHeartbeats")]
		private static extern void _EnableHeartbeats(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bActive);

		internal void EnableHeartbeats([MarshalAs(UnmanagedType.U1)] bool bActive)
		{
			_EnableHeartbeats(Self, bActive);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_SetHeartbeatInterval")]
		private static extern void _SetHeartbeatInterval(IntPtr self, int iHeartbeatInterval);

		internal void SetHeartbeatInterval(int iHeartbeatInterval)
		{
			_SetHeartbeatInterval(Self, iHeartbeatInterval);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_ForceHeartbeat")]
		private static extern void _ForceHeartbeat(IntPtr self);

		internal void ForceHeartbeat()
		{
			_ForceHeartbeat(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_AssociateWithClan")]
		private static extern SteamAPICall_t _AssociateWithClan(IntPtr self, SteamId steamIDClan);

		internal CallResult<AssociateWithClanResult_t> AssociateWithClan(SteamId steamIDClan)
		{
			return new CallResult<AssociateWithClanResult_t>(_AssociateWithClan(Self, steamIDClan), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServer_ComputeNewPlayerCompatibility")]
		private static extern SteamAPICall_t _ComputeNewPlayerCompatibility(IntPtr self, SteamId steamIDNewPlayer);

		internal CallResult<ComputeNewPlayerCompatibilityResult_t> ComputeNewPlayerCompatibility(SteamId steamIDNewPlayer)
		{
			return new CallResult<ComputeNewPlayerCompatibilityResult_t>(_ComputeNewPlayerCompatibility(Self, steamIDNewPlayer), base.IsServer);
		}
	}
	internal class ISteamGameServerStats : SteamInterface
	{
		internal ISteamGameServerStats(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamGameServerStats_v001();

		public override IntPtr GetServerInterfacePointer()
		{
			return SteamAPI_SteamGameServerStats_v001();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServerStats_RequestUserStats")]
		private static extern SteamAPICall_t _RequestUserStats(IntPtr self, SteamId steamIDUser);

		internal CallResult<GSStatsReceived_t> RequestUserStats(SteamId steamIDUser)
		{
			return new CallResult<GSStatsReceived_t>(_RequestUserStats(Self, steamIDUser), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServerStats_GetUserStatInt32")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetUserStat(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, ref int pData);

		internal bool GetUserStat(SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, ref int pData)
		{
			return _GetUserStat(Self, steamIDUser, pchName, ref pData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServerStats_GetUserStatFloat")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetUserStat(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, ref float pData);

		internal bool GetUserStat(SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, ref float pData)
		{
			return _GetUserStat(Self, steamIDUser, pchName, ref pData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServerStats_GetUserAchievement")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetUserAchievement(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, [MarshalAs(UnmanagedType.U1)] ref bool pbAchieved);

		internal bool GetUserAchievement(SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, [MarshalAs(UnmanagedType.U1)] ref bool pbAchieved)
		{
			return _GetUserAchievement(Self, steamIDUser, pchName, ref pbAchieved);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServerStats_SetUserStatInt32")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetUserStat(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, int nData);

		internal bool SetUserStat(SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, int nData)
		{
			return _SetUserStat(Self, steamIDUser, pchName, nData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServerStats_SetUserStatFloat")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetUserStat(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, float fData);

		internal bool SetUserStat(SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, float fData)
		{
			return _SetUserStat(Self, steamIDUser, pchName, fData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServerStats_UpdateUserAvgRateStat")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _UpdateUserAvgRateStat(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, float flCountThisSession, double dSessionLength);

		internal bool UpdateUserAvgRateStat(SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, float flCountThisSession, double dSessionLength)
		{
			return _UpdateUserAvgRateStat(Self, steamIDUser, pchName, flCountThisSession, dSessionLength);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServerStats_SetUserAchievement")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetUserAchievement(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName);

		internal bool SetUserAchievement(SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName)
		{
			return _SetUserAchievement(Self, steamIDUser, pchName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServerStats_ClearUserAchievement")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ClearUserAchievement(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName);

		internal bool ClearUserAchievement(SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName)
		{
			return _ClearUserAchievement(Self, steamIDUser, pchName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamGameServerStats_StoreUserStats")]
		private static extern SteamAPICall_t _StoreUserStats(IntPtr self, SteamId steamIDUser);

		internal CallResult<GSStatsStored_t> StoreUserStats(SteamId steamIDUser)
		{
			return new CallResult<GSStatsStored_t>(_StoreUserStats(Self, steamIDUser), base.IsServer);
		}
	}
	internal class ISteamHTMLSurface : SteamInterface
	{
		internal ISteamHTMLSurface(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamHTMLSurface_v005();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamHTMLSurface_v005();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_Init")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _Init(IntPtr self);

		internal bool Init()
		{
			return _Init(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_Shutdown")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _Shutdown(IntPtr self);

		internal bool Shutdown()
		{
			return _Shutdown(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_CreateBrowser")]
		private static extern SteamAPICall_t _CreateBrowser(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchUserAgent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchUserCSS);

		internal CallResult<HTML_BrowserReady_t> CreateBrowser([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchUserAgent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchUserCSS)
		{
			return new CallResult<HTML_BrowserReady_t>(_CreateBrowser(Self, pchUserAgent, pchUserCSS), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_RemoveBrowser")]
		private static extern void _RemoveBrowser(IntPtr self, HHTMLBrowser unBrowserHandle);

		internal void RemoveBrowser(HHTMLBrowser unBrowserHandle)
		{
			_RemoveBrowser(Self, unBrowserHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_LoadURL")]
		private static extern void _LoadURL(IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchURL, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPostData);

		internal void LoadURL(HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchURL, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPostData)
		{
			_LoadURL(Self, unBrowserHandle, pchURL, pchPostData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetSize")]
		private static extern void _SetSize(IntPtr self, HHTMLBrowser unBrowserHandle, uint unWidth, uint unHeight);

		internal void SetSize(HHTMLBrowser unBrowserHandle, uint unWidth, uint unHeight)
		{
			_SetSize(Self, unBrowserHandle, unWidth, unHeight);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_StopLoad")]
		private static extern void _StopLoad(IntPtr self, HHTMLBrowser unBrowserHandle);

		internal void StopLoad(HHTMLBrowser unBrowserHandle)
		{
			_StopLoad(Self, unBrowserHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_Reload")]
		private static extern void _Reload(IntPtr self, HHTMLBrowser unBrowserHandle);

		internal void Reload(HHTMLBrowser unBrowserHandle)
		{
			_Reload(Self, unBrowserHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_GoBack")]
		private static extern void _GoBack(IntPtr self, HHTMLBrowser unBrowserHandle);

		internal void GoBack(HHTMLBrowser unBrowserHandle)
		{
			_GoBack(Self, unBrowserHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_GoForward")]
		private static extern void _GoForward(IntPtr self, HHTMLBrowser unBrowserHandle);

		internal void GoForward(HHTMLBrowser unBrowserHandle)
		{
			_GoForward(Self, unBrowserHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_AddHeader")]
		private static extern void _AddHeader(IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue);

		internal void AddHeader(HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue)
		{
			_AddHeader(Self, unBrowserHandle, pchKey, pchValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_ExecuteJavascript")]
		private static extern void _ExecuteJavascript(IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchScript);

		internal void ExecuteJavascript(HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchScript)
		{
			_ExecuteJavascript(Self, unBrowserHandle, pchScript);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_MouseUp")]
		private static extern void _MouseUp(IntPtr self, HHTMLBrowser unBrowserHandle, IntPtr eMouseButton);

		internal void MouseUp(HHTMLBrowser unBrowserHandle, IntPtr eMouseButton)
		{
			_MouseUp(Self, unBrowserHandle, eMouseButton);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_MouseDown")]
		private static extern void _MouseDown(IntPtr self, HHTMLBrowser unBrowserHandle, IntPtr eMouseButton);

		internal void MouseDown(HHTMLBrowser unBrowserHandle, IntPtr eMouseButton)
		{
			_MouseDown(Self, unBrowserHandle, eMouseButton);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_MouseDoubleClick")]
		private static extern void _MouseDoubleClick(IntPtr self, HHTMLBrowser unBrowserHandle, IntPtr eMouseButton);

		internal void MouseDoubleClick(HHTMLBrowser unBrowserHandle, IntPtr eMouseButton)
		{
			_MouseDoubleClick(Self, unBrowserHandle, eMouseButton);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_MouseMove")]
		private static extern void _MouseMove(IntPtr self, HHTMLBrowser unBrowserHandle, int x, int y);

		internal void MouseMove(HHTMLBrowser unBrowserHandle, int x, int y)
		{
			_MouseMove(Self, unBrowserHandle, x, y);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_MouseWheel")]
		private static extern void _MouseWheel(IntPtr self, HHTMLBrowser unBrowserHandle, int nDelta);

		internal void MouseWheel(HHTMLBrowser unBrowserHandle, int nDelta)
		{
			_MouseWheel(Self, unBrowserHandle, nDelta);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_KeyDown")]
		private static extern void _KeyDown(IntPtr self, HHTMLBrowser unBrowserHandle, uint nNativeKeyCode, IntPtr eHTMLKeyModifiers, [MarshalAs(UnmanagedType.U1)] bool bIsSystemKey);

		internal void KeyDown(HHTMLBrowser unBrowserHandle, uint nNativeKeyCode, IntPtr eHTMLKeyModifiers, [MarshalAs(UnmanagedType.U1)] bool bIsSystemKey)
		{
			_KeyDown(Self, unBrowserHandle, nNativeKeyCode, eHTMLKeyModifiers, bIsSystemKey);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_KeyUp")]
		private static extern void _KeyUp(IntPtr self, HHTMLBrowser unBrowserHandle, uint nNativeKeyCode, IntPtr eHTMLKeyModifiers);

		internal void KeyUp(HHTMLBrowser unBrowserHandle, uint nNativeKeyCode, IntPtr eHTMLKeyModifiers)
		{
			_KeyUp(Self, unBrowserHandle, nNativeKeyCode, eHTMLKeyModifiers);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_KeyChar")]
		private static extern void _KeyChar(IntPtr self, HHTMLBrowser unBrowserHandle, uint cUnicodeChar, IntPtr eHTMLKeyModifiers);

		internal void KeyChar(HHTMLBrowser unBrowserHandle, uint cUnicodeChar, IntPtr eHTMLKeyModifiers)
		{
			_KeyChar(Self, unBrowserHandle, cUnicodeChar, eHTMLKeyModifiers);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetHorizontalScroll")]
		private static extern void _SetHorizontalScroll(IntPtr self, HHTMLBrowser unBrowserHandle, uint nAbsolutePixelScroll);

		internal void SetHorizontalScroll(HHTMLBrowser unBrowserHandle, uint nAbsolutePixelScroll)
		{
			_SetHorizontalScroll(Self, unBrowserHandle, nAbsolutePixelScroll);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetVerticalScroll")]
		private static extern void _SetVerticalScroll(IntPtr self, HHTMLBrowser unBrowserHandle, uint nAbsolutePixelScroll);

		internal void SetVerticalScroll(HHTMLBrowser unBrowserHandle, uint nAbsolutePixelScroll)
		{
			_SetVerticalScroll(Self, unBrowserHandle, nAbsolutePixelScroll);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetKeyFocus")]
		private static extern void _SetKeyFocus(IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.U1)] bool bHasKeyFocus);

		internal void SetKeyFocus(HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.U1)] bool bHasKeyFocus)
		{
			_SetKeyFocus(Self, unBrowserHandle, bHasKeyFocus);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_ViewSource")]
		private static extern void _ViewSource(IntPtr self, HHTMLBrowser unBrowserHandle);

		internal void ViewSource(HHTMLBrowser unBrowserHandle)
		{
			_ViewSource(Self, unBrowserHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_CopyToClipboard")]
		private static extern void _CopyToClipboard(IntPtr self, HHTMLBrowser unBrowserHandle);

		internal void CopyToClipboard(HHTMLBrowser unBrowserHandle)
		{
			_CopyToClipboard(Self, unBrowserHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_PasteFromClipboard")]
		private static extern void _PasteFromClipboard(IntPtr self, HHTMLBrowser unBrowserHandle);

		internal void PasteFromClipboard(HHTMLBrowser unBrowserHandle)
		{
			_PasteFromClipboard(Self, unBrowserHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_Find")]
		private static extern void _Find(IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchSearchStr, [MarshalAs(UnmanagedType.U1)] bool bCurrentlyInFind, [MarshalAs(UnmanagedType.U1)] bool bReverse);

		internal void Find(HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchSearchStr, [MarshalAs(UnmanagedType.U1)] bool bCurrentlyInFind, [MarshalAs(UnmanagedType.U1)] bool bReverse)
		{
			_Find(Self, unBrowserHandle, pchSearchStr, bCurrentlyInFind, bReverse);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_StopFind")]
		private static extern void _StopFind(IntPtr self, HHTMLBrowser unBrowserHandle);

		internal void StopFind(HHTMLBrowser unBrowserHandle)
		{
			_StopFind(Self, unBrowserHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_GetLinkAtPosition")]
		private static extern void _GetLinkAtPosition(IntPtr self, HHTMLBrowser unBrowserHandle, int x, int y);

		internal void GetLinkAtPosition(HHTMLBrowser unBrowserHandle, int x, int y)
		{
			_GetLinkAtPosition(Self, unBrowserHandle, x, y);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetCookie")]
		private static extern void _SetCookie(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchHostname, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPath, RTime32 nExpires, [MarshalAs(UnmanagedType.U1)] bool bSecure, [MarshalAs(UnmanagedType.U1)] bool bHTTPOnly);

		internal void SetCookie([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchHostname, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPath, RTime32 nExpires, [MarshalAs(UnmanagedType.U1)] bool bSecure, [MarshalAs(UnmanagedType.U1)] bool bHTTPOnly)
		{
			_SetCookie(Self, pchHostname, pchKey, pchValue, pchPath, nExpires, bSecure, bHTTPOnly);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetPageScaleFactor")]
		private static extern void _SetPageScaleFactor(IntPtr self, HHTMLBrowser unBrowserHandle, float flZoom, int nPointX, int nPointY);

		internal void SetPageScaleFactor(HHTMLBrowser unBrowserHandle, float flZoom, int nPointX, int nPointY)
		{
			_SetPageScaleFactor(Self, unBrowserHandle, flZoom, nPointX, nPointY);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetBackgroundMode")]
		private static extern void _SetBackgroundMode(IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.U1)] bool bBackgroundMode);

		internal void SetBackgroundMode(HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.U1)] bool bBackgroundMode)
		{
			_SetBackgroundMode(Self, unBrowserHandle, bBackgroundMode);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetDPIScalingFactor")]
		private static extern void _SetDPIScalingFactor(IntPtr self, HHTMLBrowser unBrowserHandle, float flDPIScaling);

		internal void SetDPIScalingFactor(HHTMLBrowser unBrowserHandle, float flDPIScaling)
		{
			_SetDPIScalingFactor(Self, unBrowserHandle, flDPIScaling);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_OpenDeveloperTools")]
		private static extern void _OpenDeveloperTools(IntPtr self, HHTMLBrowser unBrowserHandle);

		internal void OpenDeveloperTools(HHTMLBrowser unBrowserHandle)
		{
			_OpenDeveloperTools(Self, unBrowserHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_AllowStartRequest")]
		private static extern void _AllowStartRequest(IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.U1)] bool bAllowed);

		internal void AllowStartRequest(HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.U1)] bool bAllowed)
		{
			_AllowStartRequest(Self, unBrowserHandle, bAllowed);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_JSDialogResponse")]
		private static extern void _JSDialogResponse(IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.U1)] bool bResult);

		internal void JSDialogResponse(HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.U1)] bool bResult)
		{
			_JSDialogResponse(Self, unBrowserHandle, bResult);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTMLSurface_FileLoadDialogResponse")]
		private static extern void _FileLoadDialogResponse(IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchSelectedFiles);

		internal void FileLoadDialogResponse(HHTMLBrowser unBrowserHandle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchSelectedFiles)
		{
			_FileLoadDialogResponse(Self, unBrowserHandle, pchSelectedFiles);
		}
	}
	internal class ISteamHTTP : SteamInterface
	{
		internal ISteamHTTP(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamHTTP_v003();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamHTTP_v003();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamGameServerHTTP_v003();

		public override IntPtr GetServerInterfacePointer()
		{
			return SteamAPI_SteamGameServerHTTP_v003();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_CreateHTTPRequest")]
		private static extern HTTPRequestHandle _CreateHTTPRequest(IntPtr self, HTTPMethod eHTTPRequestMethod, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchAbsoluteURL);

		internal HTTPRequestHandle CreateHTTPRequest(HTTPMethod eHTTPRequestMethod, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchAbsoluteURL)
		{
			return _CreateHTTPRequest(Self, eHTTPRequestMethod, pchAbsoluteURL);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestContextValue")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetHTTPRequestContextValue(IntPtr self, HTTPRequestHandle hRequest, ulong ulContextValue);

		internal bool SetHTTPRequestContextValue(HTTPRequestHandle hRequest, ulong ulContextValue)
		{
			return _SetHTTPRequestContextValue(Self, hRequest, ulContextValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestNetworkActivityTimeout")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetHTTPRequestNetworkActivityTimeout(IntPtr self, HTTPRequestHandle hRequest, uint unTimeoutSeconds);

		internal bool SetHTTPRequestNetworkActivityTimeout(HTTPRequestHandle hRequest, uint unTimeoutSeconds)
		{
			return _SetHTTPRequestNetworkActivityTimeout(Self, hRequest, unTimeoutSeconds);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestHeaderValue")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetHTTPRequestHeaderValue(IntPtr self, HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchHeaderName, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchHeaderValue);

		internal bool SetHTTPRequestHeaderValue(HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchHeaderName, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchHeaderValue)
		{
			return _SetHTTPRequestHeaderValue(Self, hRequest, pchHeaderName, pchHeaderValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestGetOrPostParameter")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetHTTPRequestGetOrPostParameter(IntPtr self, HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchParamName, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchParamValue);

		internal bool SetHTTPRequestGetOrPostParameter(HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchParamName, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchParamValue)
		{
			return _SetHTTPRequestGetOrPostParameter(Self, hRequest, pchParamName, pchParamValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_SendHTTPRequest")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SendHTTPRequest(IntPtr self, HTTPRequestHandle hRequest, ref SteamAPICall_t pCallHandle);

		internal bool SendHTTPRequest(HTTPRequestHandle hRequest, ref SteamAPICall_t pCallHandle)
		{
			return _SendHTTPRequest(Self, hRequest, ref pCallHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_SendHTTPRequestAndStreamResponse")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SendHTTPRequestAndStreamResponse(IntPtr self, HTTPRequestHandle hRequest, ref SteamAPICall_t pCallHandle);

		internal bool SendHTTPRequestAndStreamResponse(HTTPRequestHandle hRequest, ref SteamAPICall_t pCallHandle)
		{
			return _SendHTTPRequestAndStreamResponse(Self, hRequest, ref pCallHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_DeferHTTPRequest")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _DeferHTTPRequest(IntPtr self, HTTPRequestHandle hRequest);

		internal bool DeferHTTPRequest(HTTPRequestHandle hRequest)
		{
			return _DeferHTTPRequest(Self, hRequest);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_PrioritizeHTTPRequest")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _PrioritizeHTTPRequest(IntPtr self, HTTPRequestHandle hRequest);

		internal bool PrioritizeHTTPRequest(HTTPRequestHandle hRequest)
		{
			return _PrioritizeHTTPRequest(Self, hRequest);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_GetHTTPResponseHeaderSize")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetHTTPResponseHeaderSize(IntPtr self, HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchHeaderName, ref uint unResponseHeaderSize);

		internal bool GetHTTPResponseHeaderSize(HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchHeaderName, ref uint unResponseHeaderSize)
		{
			return _GetHTTPResponseHeaderSize(Self, hRequest, pchHeaderName, ref unResponseHeaderSize);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_GetHTTPResponseHeaderValue")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetHTTPResponseHeaderValue(IntPtr self, HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchHeaderName, ref byte pHeaderValueBuffer, uint unBufferSize);

		internal bool GetHTTPResponseHeaderValue(HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchHeaderName, ref byte pHeaderValueBuffer, uint unBufferSize)
		{
			return _GetHTTPResponseHeaderValue(Self, hRequest, pchHeaderName, ref pHeaderValueBuffer, unBufferSize);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_GetHTTPResponseBodySize")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetHTTPResponseBodySize(IntPtr self, HTTPRequestHandle hRequest, ref uint unBodySize);

		internal bool GetHTTPResponseBodySize(HTTPRequestHandle hRequest, ref uint unBodySize)
		{
			return _GetHTTPResponseBodySize(Self, hRequest, ref unBodySize);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_GetHTTPResponseBodyData")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetHTTPResponseBodyData(IntPtr self, HTTPRequestHandle hRequest, ref byte pBodyDataBuffer, uint unBufferSize);

		internal bool GetHTTPResponseBodyData(HTTPRequestHandle hRequest, ref byte pBodyDataBuffer, uint unBufferSize)
		{
			return _GetHTTPResponseBodyData(Self, hRequest, ref pBodyDataBuffer, unBufferSize);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_GetHTTPStreamingResponseBodyData")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetHTTPStreamingResponseBodyData(IntPtr self, HTTPRequestHandle hRequest, uint cOffset, ref byte pBodyDataBuffer, uint unBufferSize);

		internal bool GetHTTPStreamingResponseBodyData(HTTPRequestHandle hRequest, uint cOffset, ref byte pBodyDataBuffer, uint unBufferSize)
		{
			return _GetHTTPStreamingResponseBodyData(Self, hRequest, cOffset, ref pBodyDataBuffer, unBufferSize);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_ReleaseHTTPRequest")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ReleaseHTTPRequest(IntPtr self, HTTPRequestHandle hRequest);

		internal bool ReleaseHTTPRequest(HTTPRequestHandle hRequest)
		{
			return _ReleaseHTTPRequest(Self, hRequest);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_GetHTTPDownloadProgressPct")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetHTTPDownloadProgressPct(IntPtr self, HTTPRequestHandle hRequest, ref float pflPercentOut);

		internal bool GetHTTPDownloadProgressPct(HTTPRequestHandle hRequest, ref float pflPercentOut)
		{
			return _GetHTTPDownloadProgressPct(Self, hRequest, ref pflPercentOut);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestRawPostBody")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetHTTPRequestRawPostBody(IntPtr self, HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchContentType, [In][Out] byte[] pubBody, uint unBodyLen);

		internal bool SetHTTPRequestRawPostBody(HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchContentType, [In][Out] byte[] pubBody, uint unBodyLen)
		{
			return _SetHTTPRequestRawPostBody(Self, hRequest, pchContentType, pubBody, unBodyLen);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_CreateCookieContainer")]
		private static extern HTTPCookieContainerHandle _CreateCookieContainer(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bAllowResponsesToModify);

		internal HTTPCookieContainerHandle CreateCookieContainer([MarshalAs(UnmanagedType.U1)] bool bAllowResponsesToModify)
		{
			return _CreateCookieContainer(Self, bAllowResponsesToModify);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_ReleaseCookieContainer")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ReleaseCookieContainer(IntPtr self, HTTPCookieContainerHandle hCookieContainer);

		internal bool ReleaseCookieContainer(HTTPCookieContainerHandle hCookieContainer)
		{
			return _ReleaseCookieContainer(Self, hCookieContainer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_SetCookie")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetCookie(IntPtr self, HTTPCookieContainerHandle hCookieContainer, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchHost, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchUrl, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchCookie);

		internal bool SetCookie(HTTPCookieContainerHandle hCookieContainer, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchHost, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchUrl, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchCookie)
		{
			return _SetCookie(Self, hCookieContainer, pchHost, pchUrl, pchCookie);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestCookieContainer")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetHTTPRequestCookieContainer(IntPtr self, HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer);

		internal bool SetHTTPRequestCookieContainer(HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer)
		{
			return _SetHTTPRequestCookieContainer(Self, hRequest, hCookieContainer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestUserAgentInfo")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetHTTPRequestUserAgentInfo(IntPtr self, HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchUserAgentInfo);

		internal bool SetHTTPRequestUserAgentInfo(HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchUserAgentInfo)
		{
			return _SetHTTPRequestUserAgentInfo(Self, hRequest, pchUserAgentInfo);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestRequiresVerifiedCertificate")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetHTTPRequestRequiresVerifiedCertificate(IntPtr self, HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.U1)] bool bRequireVerifiedCertificate);

		internal bool SetHTTPRequestRequiresVerifiedCertificate(HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.U1)] bool bRequireVerifiedCertificate)
		{
			return _SetHTTPRequestRequiresVerifiedCertificate(Self, hRequest, bRequireVerifiedCertificate);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestAbsoluteTimeoutMS")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetHTTPRequestAbsoluteTimeoutMS(IntPtr self, HTTPRequestHandle hRequest, uint unMilliseconds);

		internal bool SetHTTPRequestAbsoluteTimeoutMS(HTTPRequestHandle hRequest, uint unMilliseconds)
		{
			return _SetHTTPRequestAbsoluteTimeoutMS(Self, hRequest, unMilliseconds);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamHTTP_GetHTTPRequestWasTimedOut")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetHTTPRequestWasTimedOut(IntPtr self, HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.U1)] ref bool pbWasTimedOut);

		internal bool GetHTTPRequestWasTimedOut(HTTPRequestHandle hRequest, [MarshalAs(UnmanagedType.U1)] ref bool pbWasTimedOut)
		{
			return _GetHTTPRequestWasTimedOut(Self, hRequest, ref pbWasTimedOut);
		}
	}
	internal class ISteamInput : SteamInterface
	{
		internal ISteamInput(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamInput_v001();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamInput_v001();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_Init")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _Init(IntPtr self);

		internal bool Init()
		{
			return _Init(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_Shutdown")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _Shutdown(IntPtr self);

		internal bool Shutdown()
		{
			return _Shutdown(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_RunFrame")]
		private static extern void _RunFrame(IntPtr self);

		internal void RunFrame()
		{
			_RunFrame(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetConnectedControllers")]
		private static extern int _GetConnectedControllers(IntPtr self, [In][Out] InputHandle_t[] handlesOut);

		internal int GetConnectedControllers([In][Out] InputHandle_t[] handlesOut)
		{
			return _GetConnectedControllers(Self, handlesOut);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetActionSetHandle")]
		private static extern InputActionSetHandle_t _GetActionSetHandle(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionSetName);

		internal InputActionSetHandle_t GetActionSetHandle([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionSetName)
		{
			return _GetActionSetHandle(Self, pszActionSetName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_ActivateActionSet")]
		private static extern void _ActivateActionSet(IntPtr self, InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle);

		internal void ActivateActionSet(InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle)
		{
			_ActivateActionSet(Self, inputHandle, actionSetHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetCurrentActionSet")]
		private static extern InputActionSetHandle_t _GetCurrentActionSet(IntPtr self, InputHandle_t inputHandle);

		internal InputActionSetHandle_t GetCurrentActionSet(InputHandle_t inputHandle)
		{
			return _GetCurrentActionSet(Self, inputHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_ActivateActionSetLayer")]
		private static extern void _ActivateActionSetLayer(IntPtr self, InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle);

		internal void ActivateActionSetLayer(InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle)
		{
			_ActivateActionSetLayer(Self, inputHandle, actionSetLayerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_DeactivateActionSetLayer")]
		private static extern void _DeactivateActionSetLayer(IntPtr self, InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle);

		internal void DeactivateActionSetLayer(InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle)
		{
			_DeactivateActionSetLayer(Self, inputHandle, actionSetLayerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_DeactivateAllActionSetLayers")]
		private static extern void _DeactivateAllActionSetLayers(IntPtr self, InputHandle_t inputHandle);

		internal void DeactivateAllActionSetLayers(InputHandle_t inputHandle)
		{
			_DeactivateAllActionSetLayers(Self, inputHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetActiveActionSetLayers")]
		private static extern int _GetActiveActionSetLayers(IntPtr self, InputHandle_t inputHandle, [In][Out] InputActionSetHandle_t[] handlesOut);

		internal int GetActiveActionSetLayers(InputHandle_t inputHandle, [In][Out] InputActionSetHandle_t[] handlesOut)
		{
			return _GetActiveActionSetLayers(Self, inputHandle, handlesOut);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetDigitalActionHandle")]
		private static extern InputDigitalActionHandle_t _GetDigitalActionHandle(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionName);

		internal InputDigitalActionHandle_t GetDigitalActionHandle([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionName)
		{
			return _GetDigitalActionHandle(Self, pszActionName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetDigitalActionData")]
		private static extern DigitalState _GetDigitalActionData(IntPtr self, InputHandle_t inputHandle, InputDigitalActionHandle_t digitalActionHandle);

		internal DigitalState GetDigitalActionData(InputHandle_t inputHandle, InputDigitalActionHandle_t digitalActionHandle)
		{
			return _GetDigitalActionData(Self, inputHandle, digitalActionHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetDigitalActionOrigins")]
		private static extern int _GetDigitalActionOrigins(IntPtr self, InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputDigitalActionHandle_t digitalActionHandle, ref InputActionOrigin originsOut);

		internal int GetDigitalActionOrigins(InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputDigitalActionHandle_t digitalActionHandle, ref InputActionOrigin originsOut)
		{
			return _GetDigitalActionOrigins(Self, inputHandle, actionSetHandle, digitalActionHandle, ref originsOut);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetAnalogActionHandle")]
		private static extern InputAnalogActionHandle_t _GetAnalogActionHandle(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionName);

		internal InputAnalogActionHandle_t GetAnalogActionHandle([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionName)
		{
			return _GetAnalogActionHandle(Self, pszActionName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetAnalogActionData")]
		private static extern AnalogState _GetAnalogActionData(IntPtr self, InputHandle_t inputHandle, InputAnalogActionHandle_t analogActionHandle);

		internal AnalogState GetAnalogActionData(InputHandle_t inputHandle, InputAnalogActionHandle_t analogActionHandle)
		{
			return _GetAnalogActionData(Self, inputHandle, analogActionHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetAnalogActionOrigins")]
		private static extern int _GetAnalogActionOrigins(IntPtr self, InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputAnalogActionHandle_t analogActionHandle, ref InputActionOrigin originsOut);

		internal int GetAnalogActionOrigins(InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputAnalogActionHandle_t analogActionHandle, ref InputActionOrigin originsOut)
		{
			return _GetAnalogActionOrigins(Self, inputHandle, actionSetHandle, analogActionHandle, ref originsOut);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetGlyphForActionOrigin")]
		private static extern Utf8StringPointer _GetGlyphForActionOrigin(IntPtr self, InputActionOrigin eOrigin);

		internal string GetGlyphForActionOrigin(InputActionOrigin eOrigin)
		{
			return _GetGlyphForActionOrigin(Self, eOrigin);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetStringForActionOrigin")]
		private static extern Utf8StringPointer _GetStringForActionOrigin(IntPtr self, InputActionOrigin eOrigin);

		internal string GetStringForActionOrigin(InputActionOrigin eOrigin)
		{
			return _GetStringForActionOrigin(Self, eOrigin);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_StopAnalogActionMomentum")]
		private static extern void _StopAnalogActionMomentum(IntPtr self, InputHandle_t inputHandle, InputAnalogActionHandle_t eAction);

		internal void StopAnalogActionMomentum(InputHandle_t inputHandle, InputAnalogActionHandle_t eAction)
		{
			_StopAnalogActionMomentum(Self, inputHandle, eAction);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetMotionData")]
		private static extern MotionState _GetMotionData(IntPtr self, InputHandle_t inputHandle);

		internal MotionState GetMotionData(InputHandle_t inputHandle)
		{
			return _GetMotionData(Self, inputHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_TriggerVibration")]
		private static extern void _TriggerVibration(IntPtr self, InputHandle_t inputHandle, ushort usLeftSpeed, ushort usRightSpeed);

		internal void TriggerVibration(InputHandle_t inputHandle, ushort usLeftSpeed, ushort usRightSpeed)
		{
			_TriggerVibration(Self, inputHandle, usLeftSpeed, usRightSpeed);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_SetLEDColor")]
		private static extern void _SetLEDColor(IntPtr self, InputHandle_t inputHandle, byte nColorR, byte nColorG, byte nColorB, uint nFlags);

		internal void SetLEDColor(InputHandle_t inputHandle, byte nColorR, byte nColorG, byte nColorB, uint nFlags)
		{
			_SetLEDColor(Self, inputHandle, nColorR, nColorG, nColorB, nFlags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_TriggerHapticPulse")]
		private static extern void _TriggerHapticPulse(IntPtr self, InputHandle_t inputHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec);

		internal void TriggerHapticPulse(InputHandle_t inputHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec)
		{
			_TriggerHapticPulse(Self, inputHandle, eTargetPad, usDurationMicroSec);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_TriggerRepeatedHapticPulse")]
		private static extern void _TriggerRepeatedHapticPulse(IntPtr self, InputHandle_t inputHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec, ushort usOffMicroSec, ushort unRepeat, uint nFlags);

		internal void TriggerRepeatedHapticPulse(InputHandle_t inputHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec, ushort usOffMicroSec, ushort unRepeat, uint nFlags)
		{
			_TriggerRepeatedHapticPulse(Self, inputHandle, eTargetPad, usDurationMicroSec, usOffMicroSec, unRepeat, nFlags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_ShowBindingPanel")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ShowBindingPanel(IntPtr self, InputHandle_t inputHandle);

		internal bool ShowBindingPanel(InputHandle_t inputHandle)
		{
			return _ShowBindingPanel(Self, inputHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetInputTypeForHandle")]
		private static extern InputType _GetInputTypeForHandle(IntPtr self, InputHandle_t inputHandle);

		internal InputType GetInputTypeForHandle(InputHandle_t inputHandle)
		{
			return _GetInputTypeForHandle(Self, inputHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetControllerForGamepadIndex")]
		private static extern InputHandle_t _GetControllerForGamepadIndex(IntPtr self, int nIndex);

		internal InputHandle_t GetControllerForGamepadIndex(int nIndex)
		{
			return _GetControllerForGamepadIndex(Self, nIndex);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetGamepadIndexForController")]
		private static extern int _GetGamepadIndexForController(IntPtr self, InputHandle_t ulinputHandle);

		internal int GetGamepadIndexForController(InputHandle_t ulinputHandle)
		{
			return _GetGamepadIndexForController(Self, ulinputHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetStringForXboxOrigin")]
		private static extern Utf8StringPointer _GetStringForXboxOrigin(IntPtr self, XboxOrigin eOrigin);

		internal string GetStringForXboxOrigin(XboxOrigin eOrigin)
		{
			return _GetStringForXboxOrigin(Self, eOrigin);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetGlyphForXboxOrigin")]
		private static extern Utf8StringPointer _GetGlyphForXboxOrigin(IntPtr self, XboxOrigin eOrigin);

		internal string GetGlyphForXboxOrigin(XboxOrigin eOrigin)
		{
			return _GetGlyphForXboxOrigin(Self, eOrigin);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetActionOriginFromXboxOrigin")]
		private static extern InputActionOrigin _GetActionOriginFromXboxOrigin(IntPtr self, InputHandle_t inputHandle, XboxOrigin eOrigin);

		internal InputActionOrigin GetActionOriginFromXboxOrigin(InputHandle_t inputHandle, XboxOrigin eOrigin)
		{
			return _GetActionOriginFromXboxOrigin(Self, inputHandle, eOrigin);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_TranslateActionOrigin")]
		private static extern InputActionOrigin _TranslateActionOrigin(IntPtr self, InputType eDestinationInputType, InputActionOrigin eSourceOrigin);

		internal InputActionOrigin TranslateActionOrigin(InputType eDestinationInputType, InputActionOrigin eSourceOrigin)
		{
			return _TranslateActionOrigin(Self, eDestinationInputType, eSourceOrigin);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetDeviceBindingRevision")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetDeviceBindingRevision(IntPtr self, InputHandle_t inputHandle, ref int pMajor, ref int pMinor);

		internal bool GetDeviceBindingRevision(InputHandle_t inputHandle, ref int pMajor, ref int pMinor)
		{
			return _GetDeviceBindingRevision(Self, inputHandle, ref pMajor, ref pMinor);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInput_GetRemotePlaySessionID")]
		private static extern uint _GetRemotePlaySessionID(IntPtr self, InputHandle_t inputHandle);

		internal uint GetRemotePlaySessionID(InputHandle_t inputHandle)
		{
			return _GetRemotePlaySessionID(Self, inputHandle);
		}
	}
	internal class ISteamInventory : SteamInterface
	{
		internal ISteamInventory(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamInventory_v003();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamInventory_v003();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamGameServerInventory_v003();

		public override IntPtr GetServerInterfacePointer()
		{
			return SteamAPI_SteamGameServerInventory_v003();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_GetResultStatus")]
		private static extern Result _GetResultStatus(IntPtr self, SteamInventoryResult_t resultHandle);

		internal Result GetResultStatus(SteamInventoryResult_t resultHandle)
		{
			return _GetResultStatus(Self, resultHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_GetResultItems")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetResultItems(IntPtr self, SteamInventoryResult_t resultHandle, [In][Out] SteamItemDetails_t[] pOutItemsArray, ref uint punOutItemsArraySize);

		internal bool GetResultItems(SteamInventoryResult_t resultHandle, [In][Out] SteamItemDetails_t[] pOutItemsArray, ref uint punOutItemsArraySize)
		{
			return _GetResultItems(Self, resultHandle, pOutItemsArray, ref punOutItemsArraySize);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_GetResultItemProperty")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetResultItemProperty(IntPtr self, SteamInventoryResult_t resultHandle, uint unItemIndex, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyName, IntPtr pchValueBuffer, ref uint punValueBufferSizeOut);

		internal bool GetResultItemProperty(SteamInventoryResult_t resultHandle, uint unItemIndex, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyName, out string pchValueBuffer, ref uint punValueBufferSizeOut)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _GetResultItemProperty(Self, resultHandle, unItemIndex, pchPropertyName, intPtr, ref punValueBufferSizeOut);
			pchValueBuffer = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_GetResultTimestamp")]
		private static extern uint _GetResultTimestamp(IntPtr self, SteamInventoryResult_t resultHandle);

		internal uint GetResultTimestamp(SteamInventoryResult_t resultHandle)
		{
			return _GetResultTimestamp(Self, resultHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_CheckResultSteamID")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _CheckResultSteamID(IntPtr self, SteamInventoryResult_t resultHandle, SteamId steamIDExpected);

		internal bool CheckResultSteamID(SteamInventoryResult_t resultHandle, SteamId steamIDExpected)
		{
			return _CheckResultSteamID(Self, resultHandle, steamIDExpected);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_DestroyResult")]
		private static extern void _DestroyResult(IntPtr self, SteamInventoryResult_t resultHandle);

		internal void DestroyResult(SteamInventoryResult_t resultHandle)
		{
			_DestroyResult(Self, resultHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_GetAllItems")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetAllItems(IntPtr self, ref SteamInventoryResult_t pResultHandle);

		internal bool GetAllItems(ref SteamInventoryResult_t pResultHandle)
		{
			return _GetAllItems(Self, ref pResultHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_GetItemsByID")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetItemsByID(IntPtr self, ref SteamInventoryResult_t pResultHandle, ref InventoryItemId pInstanceIDs, uint unCountInstanceIDs);

		internal bool GetItemsByID(ref SteamInventoryResult_t pResultHandle, ref InventoryItemId pInstanceIDs, uint unCountInstanceIDs)
		{
			return _GetItemsByID(Self, ref pResultHandle, ref pInstanceIDs, unCountInstanceIDs);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_SerializeResult")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SerializeResult(IntPtr self, SteamInventoryResult_t resultHandle, IntPtr pOutBuffer, ref uint punOutBufferSize);

		internal bool SerializeResult(SteamInventoryResult_t resultHandle, IntPtr pOutBuffer, ref uint punOutBufferSize)
		{
			return _SerializeResult(Self, resultHandle, pOutBuffer, ref punOutBufferSize);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_DeserializeResult")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _DeserializeResult(IntPtr self, ref SteamInventoryResult_t pOutResultHandle, IntPtr pBuffer, uint unBufferSize, [MarshalAs(UnmanagedType.U1)] bool bRESERVED_MUST_BE_FALSE);

		internal bool DeserializeResult(ref SteamInventoryResult_t pOutResultHandle, IntPtr pBuffer, uint unBufferSize, [MarshalAs(UnmanagedType.U1)] bool bRESERVED_MUST_BE_FALSE)
		{
			return _DeserializeResult(Self, ref pOutResultHandle, pBuffer, unBufferSize, bRESERVED_MUST_BE_FALSE);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_GenerateItems")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GenerateItems(IntPtr self, ref SteamInventoryResult_t pResultHandle, [In][Out] InventoryDefId[] pArrayItemDefs, [In][Out] uint[] punArrayQuantity, uint unArrayLength);

		internal bool GenerateItems(ref SteamInventoryResult_t pResultHandle, [In][Out] InventoryDefId[] pArrayItemDefs, [In][Out] uint[] punArrayQuantity, uint unArrayLength)
		{
			return _GenerateItems(Self, ref pResultHandle, pArrayItemDefs, punArrayQuantity, unArrayLength);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_GrantPromoItems")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GrantPromoItems(IntPtr self, ref SteamInventoryResult_t pResultHandle);

		internal bool GrantPromoItems(ref SteamInventoryResult_t pResultHandle)
		{
			return _GrantPromoItems(Self, ref pResultHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_AddPromoItem")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _AddPromoItem(IntPtr self, ref SteamInventoryResult_t pResultHandle, InventoryDefId itemDef);

		internal bool AddPromoItem(ref SteamInventoryResult_t pResultHandle, InventoryDefId itemDef)
		{
			return _AddPromoItem(Self, ref pResultHandle, itemDef);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_AddPromoItems")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _AddPromoItems(IntPtr self, ref SteamInventoryResult_t pResultHandle, [In][Out] InventoryDefId[] pArrayItemDefs, uint unArrayLength);

		internal bool AddPromoItems(ref SteamInventoryResult_t pResultHandle, [In][Out] InventoryDefId[] pArrayItemDefs, uint unArrayLength)
		{
			return _AddPromoItems(Self, ref pResultHandle, pArrayItemDefs, unArrayLength);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_ConsumeItem")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ConsumeItem(IntPtr self, ref SteamInventoryResult_t pResultHandle, InventoryItemId itemConsume, uint unQuantity);

		internal bool ConsumeItem(ref SteamInventoryResult_t pResultHandle, InventoryItemId itemConsume, uint unQuantity)
		{
			return _ConsumeItem(Self, ref pResultHandle, itemConsume, unQuantity);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_ExchangeItems")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ExchangeItems(IntPtr self, ref SteamInventoryResult_t pResultHandle, [In][Out] InventoryDefId[] pArrayGenerate, [In][Out] uint[] punArrayGenerateQuantity, uint unArrayGenerateLength, [In][Out] InventoryItemId[] pArrayDestroy, [In][Out] uint[] punArrayDestroyQuantity, uint unArrayDestroyLength);

		internal bool ExchangeItems(ref SteamInventoryResult_t pResultHandle, [In][Out] InventoryDefId[] pArrayGenerate, [In][Out] uint[] punArrayGenerateQuantity, uint unArrayGenerateLength, [In][Out] InventoryItemId[] pArrayDestroy, [In][Out] uint[] punArrayDestroyQuantity, uint unArrayDestroyLength)
		{
			return _ExchangeItems(Self, ref pResultHandle, pArrayGenerate, punArrayGenerateQuantity, unArrayGenerateLength, pArrayDestroy, punArrayDestroyQuantity, unArrayDestroyLength);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_TransferItemQuantity")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _TransferItemQuantity(IntPtr self, ref SteamInventoryResult_t pResultHandle, InventoryItemId itemIdSource, uint unQuantity, InventoryItemId itemIdDest);

		internal bool TransferItemQuantity(ref SteamInventoryResult_t pResultHandle, InventoryItemId itemIdSource, uint unQuantity, InventoryItemId itemIdDest)
		{
			return _TransferItemQuantity(Self, ref pResultHandle, itemIdSource, unQuantity, itemIdDest);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_SendItemDropHeartbeat")]
		private static extern void _SendItemDropHeartbeat(IntPtr self);

		internal void SendItemDropHeartbeat()
		{
			_SendItemDropHeartbeat(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_TriggerItemDrop")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _TriggerItemDrop(IntPtr self, ref SteamInventoryResult_t pResultHandle, InventoryDefId dropListDefinition);

		internal bool TriggerItemDrop(ref SteamInventoryResult_t pResultHandle, InventoryDefId dropListDefinition)
		{
			return _TriggerItemDrop(Self, ref pResultHandle, dropListDefinition);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_TradeItems")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _TradeItems(IntPtr self, ref SteamInventoryResult_t pResultHandle, SteamId steamIDTradePartner, [In][Out] InventoryItemId[] pArrayGive, [In][Out] uint[] pArrayGiveQuantity, uint nArrayGiveLength, [In][Out] InventoryItemId[] pArrayGet, [In][Out] uint[] pArrayGetQuantity, uint nArrayGetLength);

		internal bool TradeItems(ref SteamInventoryResult_t pResultHandle, SteamId steamIDTradePartner, [In][Out] InventoryItemId[] pArrayGive, [In][Out] uint[] pArrayGiveQuantity, uint nArrayGiveLength, [In][Out] InventoryItemId[] pArrayGet, [In][Out] uint[] pArrayGetQuantity, uint nArrayGetLength)
		{
			return _TradeItems(Self, ref pResultHandle, steamIDTradePartner, pArrayGive, pArrayGiveQuantity, nArrayGiveLength, pArrayGet, pArrayGetQuantity, nArrayGetLength);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_LoadItemDefinitions")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _LoadItemDefinitions(IntPtr self);

		internal bool LoadItemDefinitions()
		{
			return _LoadItemDefinitions(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_GetItemDefinitionIDs")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetItemDefinitionIDs(IntPtr self, [In][Out] InventoryDefId[] pItemDefIDs, ref uint punItemDefIDsArraySize);

		internal bool GetItemDefinitionIDs([In][Out] InventoryDefId[] pItemDefIDs, ref uint punItemDefIDsArraySize)
		{
			return _GetItemDefinitionIDs(Self, pItemDefIDs, ref punItemDefIDsArraySize);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_GetItemDefinitionProperty")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetItemDefinitionProperty(IntPtr self, InventoryDefId iDefinition, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyName, IntPtr pchValueBuffer, ref uint punValueBufferSizeOut);

		internal bool GetItemDefinitionProperty(InventoryDefId iDefinition, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyName, out string pchValueBuffer, ref uint punValueBufferSizeOut)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _GetItemDefinitionProperty(Self, iDefinition, pchPropertyName, intPtr, ref punValueBufferSizeOut);
			pchValueBuffer = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_RequestEligiblePromoItemDefinitionsIDs")]
		private static extern SteamAPICall_t _RequestEligiblePromoItemDefinitionsIDs(IntPtr self, SteamId steamID);

		internal CallResult<SteamInventoryEligiblePromoItemDefIDs_t> RequestEligiblePromoItemDefinitionsIDs(SteamId steamID)
		{
			return new CallResult<SteamInventoryEligiblePromoItemDefIDs_t>(_RequestEligiblePromoItemDefinitionsIDs(Self, steamID), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_GetEligiblePromoItemDefinitionIDs")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetEligiblePromoItemDefinitionIDs(IntPtr self, SteamId steamID, [In][Out] InventoryDefId[] pItemDefIDs, ref uint punItemDefIDsArraySize);

		internal bool GetEligiblePromoItemDefinitionIDs(SteamId steamID, [In][Out] InventoryDefId[] pItemDefIDs, ref uint punItemDefIDsArraySize)
		{
			return _GetEligiblePromoItemDefinitionIDs(Self, steamID, pItemDefIDs, ref punItemDefIDsArraySize);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_StartPurchase")]
		private static extern SteamAPICall_t _StartPurchase(IntPtr self, [In][Out] InventoryDefId[] pArrayItemDefs, [In][Out] uint[] punArrayQuantity, uint unArrayLength);

		internal CallResult<SteamInventoryStartPurchaseResult_t> StartPurchase([In][Out] InventoryDefId[] pArrayItemDefs, [In][Out] uint[] punArrayQuantity, uint unArrayLength)
		{
			return new CallResult<SteamInventoryStartPurchaseResult_t>(_StartPurchase(Self, pArrayItemDefs, punArrayQuantity, unArrayLength), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_RequestPrices")]
		private static extern SteamAPICall_t _RequestPrices(IntPtr self);

		internal CallResult<SteamInventoryRequestPricesResult_t> RequestPrices()
		{
			return new CallResult<SteamInventoryRequestPricesResult_t>(_RequestPrices(Self), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_GetNumItemsWithPrices")]
		private static extern uint _GetNumItemsWithPrices(IntPtr self);

		internal uint GetNumItemsWithPrices()
		{
			return _GetNumItemsWithPrices(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_GetItemsWithPrices")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetItemsWithPrices(IntPtr self, [In][Out] InventoryDefId[] pArrayItemDefs, [In][Out] ulong[] pCurrentPrices, [In][Out] ulong[] pBasePrices, uint unArrayLength);

		internal bool GetItemsWithPrices([In][Out] InventoryDefId[] pArrayItemDefs, [In][Out] ulong[] pCurrentPrices, [In][Out] ulong[] pBasePrices, uint unArrayLength)
		{
			return _GetItemsWithPrices(Self, pArrayItemDefs, pCurrentPrices, pBasePrices, unArrayLength);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_GetItemPrice")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetItemPrice(IntPtr self, InventoryDefId iDefinition, ref ulong pCurrentPrice, ref ulong pBasePrice);

		internal bool GetItemPrice(InventoryDefId iDefinition, ref ulong pCurrentPrice, ref ulong pBasePrice)
		{
			return _GetItemPrice(Self, iDefinition, ref pCurrentPrice, ref pBasePrice);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_StartUpdateProperties")]
		private static extern SteamInventoryUpdateHandle_t _StartUpdateProperties(IntPtr self);

		internal SteamInventoryUpdateHandle_t StartUpdateProperties()
		{
			return _StartUpdateProperties(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_RemoveProperty")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _RemoveProperty(IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyName);

		internal bool RemoveProperty(SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyName)
		{
			return _RemoveProperty(Self, handle, nItemID, pchPropertyName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_SetPropertyString")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetProperty(IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyName, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyValue);

		internal bool SetProperty(SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyName, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyValue)
		{
			return _SetProperty(Self, handle, nItemID, pchPropertyName, pchPropertyValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_SetPropertyBool")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetProperty(IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyName, [MarshalAs(UnmanagedType.U1)] bool bValue);

		internal bool SetProperty(SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyName, [MarshalAs(UnmanagedType.U1)] bool bValue)
		{
			return _SetProperty(Self, handle, nItemID, pchPropertyName, bValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_SetPropertyInt64")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetProperty(IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyName, long nValue);

		internal bool SetProperty(SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyName, long nValue)
		{
			return _SetProperty(Self, handle, nItemID, pchPropertyName, nValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_SetPropertyFloat")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetProperty(IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyName, float flValue);

		internal bool SetProperty(SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPropertyName, float flValue)
		{
			return _SetProperty(Self, handle, nItemID, pchPropertyName, flValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamInventory_SubmitUpdateProperties")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SubmitUpdateProperties(IntPtr self, SteamInventoryUpdateHandle_t handle, ref SteamInventoryResult_t pResultHandle);

		internal bool SubmitUpdateProperties(SteamInventoryUpdateHandle_t handle, ref SteamInventoryResult_t pResultHandle)
		{
			return _SubmitUpdateProperties(Self, handle, ref pResultHandle);
		}
	}
	internal class ISteamMatchmaking : SteamInterface
	{
		internal ISteamMatchmaking(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamMatchmaking_v009();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamMatchmaking_v009();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_GetFavoriteGameCount")]
		private static extern int _GetFavoriteGameCount(IntPtr self);

		internal int GetFavoriteGameCount()
		{
			return _GetFavoriteGameCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_GetFavoriteGame")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetFavoriteGame(IntPtr self, int iGame, ref AppId pnAppID, ref uint pnIP, ref ushort pnConnPort, ref ushort pnQueryPort, ref uint punFlags, ref uint pRTime32LastPlayedOnServer);

		internal bool GetFavoriteGame(int iGame, ref AppId pnAppID, ref uint pnIP, ref ushort pnConnPort, ref ushort pnQueryPort, ref uint punFlags, ref uint pRTime32LastPlayedOnServer)
		{
			return _GetFavoriteGame(Self, iGame, ref pnAppID, ref pnIP, ref pnConnPort, ref pnQueryPort, ref punFlags, ref pRTime32LastPlayedOnServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_AddFavoriteGame")]
		private static extern int _AddFavoriteGame(IntPtr self, AppId nAppID, uint nIP, ushort nConnPort, ushort nQueryPort, uint unFlags, uint rTime32LastPlayedOnServer);

		internal int AddFavoriteGame(AppId nAppID, uint nIP, ushort nConnPort, ushort nQueryPort, uint unFlags, uint rTime32LastPlayedOnServer)
		{
			return _AddFavoriteGame(Self, nAppID, nIP, nConnPort, nQueryPort, unFlags, rTime32LastPlayedOnServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_RemoveFavoriteGame")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _RemoveFavoriteGame(IntPtr self, AppId nAppID, uint nIP, ushort nConnPort, ushort nQueryPort, uint unFlags);

		internal bool RemoveFavoriteGame(AppId nAppID, uint nIP, ushort nConnPort, ushort nQueryPort, uint unFlags)
		{
			return _RemoveFavoriteGame(Self, nAppID, nIP, nConnPort, nQueryPort, unFlags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_RequestLobbyList")]
		private static extern SteamAPICall_t _RequestLobbyList(IntPtr self);

		internal CallResult<LobbyMatchList_t> RequestLobbyList()
		{
			return new CallResult<LobbyMatchList_t>(_RequestLobbyList(Self), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_AddRequestLobbyListStringFilter")]
		private static extern void _AddRequestLobbyListStringFilter(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKeyToMatch, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValueToMatch, LobbyComparison eComparisonType);

		internal void AddRequestLobbyListStringFilter([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKeyToMatch, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValueToMatch, LobbyComparison eComparisonType)
		{
			_AddRequestLobbyListStringFilter(Self, pchKeyToMatch, pchValueToMatch, eComparisonType);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_AddRequestLobbyListNumericalFilter")]
		private static extern void _AddRequestLobbyListNumericalFilter(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKeyToMatch, int nValueToMatch, LobbyComparison eComparisonType);

		internal void AddRequestLobbyListNumericalFilter([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKeyToMatch, int nValueToMatch, LobbyComparison eComparisonType)
		{
			_AddRequestLobbyListNumericalFilter(Self, pchKeyToMatch, nValueToMatch, eComparisonType);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_AddRequestLobbyListNearValueFilter")]
		private static extern void _AddRequestLobbyListNearValueFilter(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKeyToMatch, int nValueToBeCloseTo);

		internal void AddRequestLobbyListNearValueFilter([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKeyToMatch, int nValueToBeCloseTo)
		{
			_AddRequestLobbyListNearValueFilter(Self, pchKeyToMatch, nValueToBeCloseTo);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_AddRequestLobbyListFilterSlotsAvailable")]
		private static extern void _AddRequestLobbyListFilterSlotsAvailable(IntPtr self, int nSlotsAvailable);

		internal void AddRequestLobbyListFilterSlotsAvailable(int nSlotsAvailable)
		{
			_AddRequestLobbyListFilterSlotsAvailable(Self, nSlotsAvailable);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_AddRequestLobbyListDistanceFilter")]
		private static extern void _AddRequestLobbyListDistanceFilter(IntPtr self, LobbyDistanceFilter eLobbyDistanceFilter);

		internal void AddRequestLobbyListDistanceFilter(LobbyDistanceFilter eLobbyDistanceFilter)
		{
			_AddRequestLobbyListDistanceFilter(Self, eLobbyDistanceFilter);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_AddRequestLobbyListResultCountFilter")]
		private static extern void _AddRequestLobbyListResultCountFilter(IntPtr self, int cMaxResults);

		internal void AddRequestLobbyListResultCountFilter(int cMaxResults)
		{
			_AddRequestLobbyListResultCountFilter(Self, cMaxResults);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_AddRequestLobbyListCompatibleMembersFilter")]
		private static extern void _AddRequestLobbyListCompatibleMembersFilter(IntPtr self, SteamId steamIDLobby);

		internal void AddRequestLobbyListCompatibleMembersFilter(SteamId steamIDLobby)
		{
			_AddRequestLobbyListCompatibleMembersFilter(Self, steamIDLobby);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_GetLobbyByIndex")]
		private static extern SteamId _GetLobbyByIndex(IntPtr self, int iLobby);

		internal SteamId GetLobbyByIndex(int iLobby)
		{
			return _GetLobbyByIndex(Self, iLobby);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_CreateLobby")]
		private static extern SteamAPICall_t _CreateLobby(IntPtr self, LobbyType eLobbyType, int cMaxMembers);

		internal CallResult<LobbyCreated_t> CreateLobby(LobbyType eLobbyType, int cMaxMembers)
		{
			return new CallResult<LobbyCreated_t>(_CreateLobby(Self, eLobbyType, cMaxMembers), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_JoinLobby")]
		private static extern SteamAPICall_t _JoinLobby(IntPtr self, SteamId steamIDLobby);

		internal CallResult<LobbyEnter_t> JoinLobby(SteamId steamIDLobby)
		{
			return new CallResult<LobbyEnter_t>(_JoinLobby(Self, steamIDLobby), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_LeaveLobby")]
		private static extern void _LeaveLobby(IntPtr self, SteamId steamIDLobby);

		internal void LeaveLobby(SteamId steamIDLobby)
		{
			_LeaveLobby(Self, steamIDLobby);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_InviteUserToLobby")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _InviteUserToLobby(IntPtr self, SteamId steamIDLobby, SteamId steamIDInvitee);

		internal bool InviteUserToLobby(SteamId steamIDLobby, SteamId steamIDInvitee)
		{
			return _InviteUserToLobby(Self, steamIDLobby, steamIDInvitee);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_GetNumLobbyMembers")]
		private static extern int _GetNumLobbyMembers(IntPtr self, SteamId steamIDLobby);

		internal int GetNumLobbyMembers(SteamId steamIDLobby)
		{
			return _GetNumLobbyMembers(Self, steamIDLobby);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_GetLobbyMemberByIndex")]
		private static extern SteamId _GetLobbyMemberByIndex(IntPtr self, SteamId steamIDLobby, int iMember);

		internal SteamId GetLobbyMemberByIndex(SteamId steamIDLobby, int iMember)
		{
			return _GetLobbyMemberByIndex(Self, steamIDLobby, iMember);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_GetLobbyData")]
		private static extern Utf8StringPointer _GetLobbyData(IntPtr self, SteamId steamIDLobby, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey);

		internal string GetLobbyData(SteamId steamIDLobby, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey)
		{
			return _GetLobbyData(Self, steamIDLobby, pchKey);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_SetLobbyData")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetLobbyData(IntPtr self, SteamId steamIDLobby, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue);

		internal bool SetLobbyData(SteamId steamIDLobby, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue)
		{
			return _SetLobbyData(Self, steamIDLobby, pchKey, pchValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_GetLobbyDataCount")]
		private static extern int _GetLobbyDataCount(IntPtr self, SteamId steamIDLobby);

		internal int GetLobbyDataCount(SteamId steamIDLobby)
		{
			return _GetLobbyDataCount(Self, steamIDLobby);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_GetLobbyDataByIndex")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetLobbyDataByIndex(IntPtr self, SteamId steamIDLobby, int iLobbyData, IntPtr pchKey, int cchKeyBufferSize, IntPtr pchValue, int cchValueBufferSize);

		internal bool GetLobbyDataByIndex(SteamId steamIDLobby, int iLobbyData, out string pchKey, out string pchValue)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			IntPtr intPtr2 = Helpers.TakeMemory();
			bool result = _GetLobbyDataByIndex(Self, steamIDLobby, iLobbyData, intPtr, 32768, intPtr2, 32768);
			pchKey = Helpers.MemoryToString(intPtr);
			pchValue = Helpers.MemoryToString(intPtr2);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_DeleteLobbyData")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _DeleteLobbyData(IntPtr self, SteamId steamIDLobby, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey);

		internal bool DeleteLobbyData(SteamId steamIDLobby, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey)
		{
			return _DeleteLobbyData(Self, steamIDLobby, pchKey);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_GetLobbyMemberData")]
		private static extern Utf8StringPointer _GetLobbyMemberData(IntPtr self, SteamId steamIDLobby, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey);

		internal string GetLobbyMemberData(SteamId steamIDLobby, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey)
		{
			return _GetLobbyMemberData(Self, steamIDLobby, steamIDUser, pchKey);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_SetLobbyMemberData")]
		private static extern void _SetLobbyMemberData(IntPtr self, SteamId steamIDLobby, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue);

		internal void SetLobbyMemberData(SteamId steamIDLobby, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue)
		{
			_SetLobbyMemberData(Self, steamIDLobby, pchKey, pchValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_SendLobbyChatMsg")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SendLobbyChatMsg(IntPtr self, SteamId steamIDLobby, IntPtr pvMsgBody, int cubMsgBody);

		internal bool SendLobbyChatMsg(SteamId steamIDLobby, IntPtr pvMsgBody, int cubMsgBody)
		{
			return _SendLobbyChatMsg(Self, steamIDLobby, pvMsgBody, cubMsgBody);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_GetLobbyChatEntry")]
		private static extern int _GetLobbyChatEntry(IntPtr self, SteamId steamIDLobby, int iChatID, ref SteamId pSteamIDUser, IntPtr pvData, int cubData, ref ChatEntryType peChatEntryType);

		internal int GetLobbyChatEntry(SteamId steamIDLobby, int iChatID, ref SteamId pSteamIDUser, IntPtr pvData, int cubData, ref ChatEntryType peChatEntryType)
		{
			return _GetLobbyChatEntry(Self, steamIDLobby, iChatID, ref pSteamIDUser, pvData, cubData, ref peChatEntryType);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_RequestLobbyData")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _RequestLobbyData(IntPtr self, SteamId steamIDLobby);

		internal bool RequestLobbyData(SteamId steamIDLobby)
		{
			return _RequestLobbyData(Self, steamIDLobby);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_SetLobbyGameServer")]
		private static extern void _SetLobbyGameServer(IntPtr self, SteamId steamIDLobby, uint unGameServerIP, ushort unGameServerPort, SteamId steamIDGameServer);

		internal void SetLobbyGameServer(SteamId steamIDLobby, uint unGameServerIP, ushort unGameServerPort, SteamId steamIDGameServer)
		{
			_SetLobbyGameServer(Self, steamIDLobby, unGameServerIP, unGameServerPort, steamIDGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_GetLobbyGameServer")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetLobbyGameServer(IntPtr self, SteamId steamIDLobby, ref uint punGameServerIP, ref ushort punGameServerPort, ref SteamId psteamIDGameServer);

		internal bool GetLobbyGameServer(SteamId steamIDLobby, ref uint punGameServerIP, ref ushort punGameServerPort, ref SteamId psteamIDGameServer)
		{
			return _GetLobbyGameServer(Self, steamIDLobby, ref punGameServerIP, ref punGameServerPort, ref psteamIDGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_SetLobbyMemberLimit")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetLobbyMemberLimit(IntPtr self, SteamId steamIDLobby, int cMaxMembers);

		internal bool SetLobbyMemberLimit(SteamId steamIDLobby, int cMaxMembers)
		{
			return _SetLobbyMemberLimit(Self, steamIDLobby, cMaxMembers);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_GetLobbyMemberLimit")]
		private static extern int _GetLobbyMemberLimit(IntPtr self, SteamId steamIDLobby);

		internal int GetLobbyMemberLimit(SteamId steamIDLobby)
		{
			return _GetLobbyMemberLimit(Self, steamIDLobby);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_SetLobbyType")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetLobbyType(IntPtr self, SteamId steamIDLobby, LobbyType eLobbyType);

		internal bool SetLobbyType(SteamId steamIDLobby, LobbyType eLobbyType)
		{
			return _SetLobbyType(Self, steamIDLobby, eLobbyType);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_SetLobbyJoinable")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetLobbyJoinable(IntPtr self, SteamId steamIDLobby, [MarshalAs(UnmanagedType.U1)] bool bLobbyJoinable);

		internal bool SetLobbyJoinable(SteamId steamIDLobby, [MarshalAs(UnmanagedType.U1)] bool bLobbyJoinable)
		{
			return _SetLobbyJoinable(Self, steamIDLobby, bLobbyJoinable);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_GetLobbyOwner")]
		private static extern SteamId _GetLobbyOwner(IntPtr self, SteamId steamIDLobby);

		internal SteamId GetLobbyOwner(SteamId steamIDLobby)
		{
			return _GetLobbyOwner(Self, steamIDLobby);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_SetLobbyOwner")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetLobbyOwner(IntPtr self, SteamId steamIDLobby, SteamId steamIDNewOwner);

		internal bool SetLobbyOwner(SteamId steamIDLobby, SteamId steamIDNewOwner)
		{
			return _SetLobbyOwner(Self, steamIDLobby, steamIDNewOwner);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmaking_SetLinkedLobby")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetLinkedLobby(IntPtr self, SteamId steamIDLobby, SteamId steamIDLobbyDependent);

		internal bool SetLinkedLobby(SteamId steamIDLobby, SteamId steamIDLobbyDependent)
		{
			return _SetLinkedLobby(Self, steamIDLobby, steamIDLobbyDependent);
		}
	}
	internal class ISteamMatchmakingPingResponse : SteamInterface
	{
		internal ISteamMatchmakingPingResponse(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingPingResponse_ServerResponded")]
		private static extern void _ServerResponded(IntPtr self, ref gameserveritem_t server);

		internal void ServerResponded(ref gameserveritem_t server)
		{
			_ServerResponded(Self, ref server);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingPingResponse_ServerFailedToRespond")]
		private static extern void _ServerFailedToRespond(IntPtr self);

		internal void ServerFailedToRespond()
		{
			_ServerFailedToRespond(Self);
		}
	}
	internal class ISteamMatchmakingPlayersResponse : SteamInterface
	{
		internal ISteamMatchmakingPlayersResponse(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingPlayersResponse_AddPlayerToList")]
		private static extern void _AddPlayerToList(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, int nScore, float flTimePlayed);

		internal void AddPlayerToList([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, int nScore, float flTimePlayed)
		{
			_AddPlayerToList(Self, pchName, nScore, flTimePlayed);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingPlayersResponse_PlayersFailedToRespond")]
		private static extern void _PlayersFailedToRespond(IntPtr self);

		internal void PlayersFailedToRespond()
		{
			_PlayersFailedToRespond(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingPlayersResponse_PlayersRefreshComplete")]
		private static extern void _PlayersRefreshComplete(IntPtr self);

		internal void PlayersRefreshComplete()
		{
			_PlayersRefreshComplete(Self);
		}
	}
	internal class ISteamMatchmakingRulesResponse : SteamInterface
	{
		internal ISteamMatchmakingRulesResponse(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingRulesResponse_RulesResponded")]
		private static extern void _RulesResponded(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchRule, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue);

		internal void RulesResponded([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchRule, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue)
		{
			_RulesResponded(Self, pchRule, pchValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingRulesResponse_RulesFailedToRespond")]
		private static extern void _RulesFailedToRespond(IntPtr self);

		internal void RulesFailedToRespond()
		{
			_RulesFailedToRespond(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingRulesResponse_RulesRefreshComplete")]
		private static extern void _RulesRefreshComplete(IntPtr self);

		internal void RulesRefreshComplete()
		{
			_RulesRefreshComplete(Self);
		}
	}
	internal class ISteamMatchmakingServerListResponse : SteamInterface
	{
		internal ISteamMatchmakingServerListResponse(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServerListResponse_ServerResponded")]
		private static extern void _ServerResponded(IntPtr self, HServerListRequest hRequest, int iServer);

		internal void ServerResponded(HServerListRequest hRequest, int iServer)
		{
			_ServerResponded(Self, hRequest, iServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServerListResponse_ServerFailedToRespond")]
		private static extern void _ServerFailedToRespond(IntPtr self, HServerListRequest hRequest, int iServer);

		internal void ServerFailedToRespond(HServerListRequest hRequest, int iServer)
		{
			_ServerFailedToRespond(Self, hRequest, iServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServerListResponse_RefreshComplete")]
		private static extern void _RefreshComplete(IntPtr self, HServerListRequest hRequest, MatchMakingServerResponse response);

		internal void RefreshComplete(HServerListRequest hRequest, MatchMakingServerResponse response)
		{
			_RefreshComplete(Self, hRequest, response);
		}
	}
	internal class ISteamMatchmakingServers : SteamInterface
	{
		internal ISteamMatchmakingServers(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamMatchmakingServers_v002();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamMatchmakingServers_v002();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_RequestInternetServerList")]
		private static extern HServerListRequest _RequestInternetServerList(IntPtr self, AppId iApp, [In][Out] ref MatchMakingKeyValuePair[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse);

		internal HServerListRequest RequestInternetServerList(AppId iApp, [In][Out] ref MatchMakingKeyValuePair[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse)
		{
			return _RequestInternetServerList(Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_RequestLANServerList")]
		private static extern HServerListRequest _RequestLANServerList(IntPtr self, AppId iApp, IntPtr pRequestServersResponse);

		internal HServerListRequest RequestLANServerList(AppId iApp, IntPtr pRequestServersResponse)
		{
			return _RequestLANServerList(Self, iApp, pRequestServersResponse);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_RequestFriendsServerList")]
		private static extern HServerListRequest _RequestFriendsServerList(IntPtr self, AppId iApp, [In][Out] ref MatchMakingKeyValuePair[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse);

		internal HServerListRequest RequestFriendsServerList(AppId iApp, [In][Out] ref MatchMakingKeyValuePair[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse)
		{
			return _RequestFriendsServerList(Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_RequestFavoritesServerList")]
		private static extern HServerListRequest _RequestFavoritesServerList(IntPtr self, AppId iApp, [In][Out] ref MatchMakingKeyValuePair[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse);

		internal HServerListRequest RequestFavoritesServerList(AppId iApp, [In][Out] ref MatchMakingKeyValuePair[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse)
		{
			return _RequestFavoritesServerList(Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_RequestHistoryServerList")]
		private static extern HServerListRequest _RequestHistoryServerList(IntPtr self, AppId iApp, [In][Out] ref MatchMakingKeyValuePair[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse);

		internal HServerListRequest RequestHistoryServerList(AppId iApp, [In][Out] ref MatchMakingKeyValuePair[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse)
		{
			return _RequestHistoryServerList(Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_RequestSpectatorServerList")]
		private static extern HServerListRequest _RequestSpectatorServerList(IntPtr self, AppId iApp, [In][Out] ref MatchMakingKeyValuePair[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse);

		internal HServerListRequest RequestSpectatorServerList(AppId iApp, [In][Out] ref MatchMakingKeyValuePair[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse)
		{
			return _RequestSpectatorServerList(Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_ReleaseRequest")]
		private static extern void _ReleaseRequest(IntPtr self, HServerListRequest hServerListRequest);

		internal void ReleaseRequest(HServerListRequest hServerListRequest)
		{
			_ReleaseRequest(Self, hServerListRequest);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_GetServerDetails")]
		private static extern IntPtr _GetServerDetails(IntPtr self, HServerListRequest hRequest, int iServer);

		internal gameserveritem_t GetServerDetails(HServerListRequest hRequest, int iServer)
		{
			return _GetServerDetails(Self, hRequest, iServer).ToType<gameserveritem_t>();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_CancelQuery")]
		private static extern void _CancelQuery(IntPtr self, HServerListRequest hRequest);

		internal void CancelQuery(HServerListRequest hRequest)
		{
			_CancelQuery(Self, hRequest);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_RefreshQuery")]
		private static extern void _RefreshQuery(IntPtr self, HServerListRequest hRequest);

		internal void RefreshQuery(HServerListRequest hRequest)
		{
			_RefreshQuery(Self, hRequest);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_IsRefreshing")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsRefreshing(IntPtr self, HServerListRequest hRequest);

		internal bool IsRefreshing(HServerListRequest hRequest)
		{
			return _IsRefreshing(Self, hRequest);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_GetServerCount")]
		private static extern int _GetServerCount(IntPtr self, HServerListRequest hRequest);

		internal int GetServerCount(HServerListRequest hRequest)
		{
			return _GetServerCount(Self, hRequest);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_RefreshServer")]
		private static extern void _RefreshServer(IntPtr self, HServerListRequest hRequest, int iServer);

		internal void RefreshServer(HServerListRequest hRequest, int iServer)
		{
			_RefreshServer(Self, hRequest, iServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_PingServer")]
		private static extern HServerQuery _PingServer(IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse);

		internal HServerQuery PingServer(uint unIP, ushort usPort, IntPtr pRequestServersResponse)
		{
			return _PingServer(Self, unIP, usPort, pRequestServersResponse);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_PlayerDetails")]
		private static extern HServerQuery _PlayerDetails(IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse);

		internal HServerQuery PlayerDetails(uint unIP, ushort usPort, IntPtr pRequestServersResponse)
		{
			return _PlayerDetails(Self, unIP, usPort, pRequestServersResponse);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_ServerRules")]
		private static extern HServerQuery _ServerRules(IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse);

		internal HServerQuery ServerRules(uint unIP, ushort usPort, IntPtr pRequestServersResponse)
		{
			return _ServerRules(Self, unIP, usPort, pRequestServersResponse);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMatchmakingServers_CancelServerQuery")]
		private static extern void _CancelServerQuery(IntPtr self, HServerQuery hServerQuery);

		internal void CancelServerQuery(HServerQuery hServerQuery)
		{
			_CancelServerQuery(Self, hServerQuery);
		}
	}
	internal class ISteamMusic : SteamInterface
	{
		internal ISteamMusic(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamMusic_v001();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamMusic_v001();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusic_BIsEnabled")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsEnabled(IntPtr self);

		internal bool BIsEnabled()
		{
			return _BIsEnabled(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusic_BIsPlaying")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsPlaying(IntPtr self);

		internal bool BIsPlaying()
		{
			return _BIsPlaying(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusic_GetPlaybackStatus")]
		private static extern MusicStatus _GetPlaybackStatus(IntPtr self);

		internal MusicStatus GetPlaybackStatus()
		{
			return _GetPlaybackStatus(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusic_Play")]
		private static extern void _Play(IntPtr self);

		internal void Play()
		{
			_Play(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusic_Pause")]
		private static extern void _Pause(IntPtr self);

		internal void Pause()
		{
			_Pause(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusic_PlayPrevious")]
		private static extern void _PlayPrevious(IntPtr self);

		internal void PlayPrevious()
		{
			_PlayPrevious(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusic_PlayNext")]
		private static extern void _PlayNext(IntPtr self);

		internal void PlayNext()
		{
			_PlayNext(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusic_SetVolume")]
		private static extern void _SetVolume(IntPtr self, float flVolume);

		internal void SetVolume(float flVolume)
		{
			_SetVolume(Self, flVolume);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusic_GetVolume")]
		private static extern float _GetVolume(IntPtr self);

		internal float GetVolume()
		{
			return _GetVolume(Self);
		}
	}
	internal class ISteamMusicRemote : SteamInterface
	{
		internal ISteamMusicRemote(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamMusicRemote_v001();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamMusicRemote_v001();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_RegisterSteamMusicRemote")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _RegisterSteamMusicRemote(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName);

		internal bool RegisterSteamMusicRemote([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName)
		{
			return _RegisterSteamMusicRemote(Self, pchName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_DeregisterSteamMusicRemote")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _DeregisterSteamMusicRemote(IntPtr self);

		internal bool DeregisterSteamMusicRemote()
		{
			return _DeregisterSteamMusicRemote(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_BIsCurrentMusicRemote")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsCurrentMusicRemote(IntPtr self);

		internal bool BIsCurrentMusicRemote()
		{
			return _BIsCurrentMusicRemote(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_BActivationSuccess")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BActivationSuccess(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bValue);

		internal bool BActivationSuccess([MarshalAs(UnmanagedType.U1)] bool bValue)
		{
			return _BActivationSuccess(Self, bValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_SetDisplayName")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetDisplayName(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchDisplayName);

		internal bool SetDisplayName([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchDisplayName)
		{
			return _SetDisplayName(Self, pchDisplayName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_SetPNGIcon_64x64")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetPNGIcon_64x64(IntPtr self, IntPtr pvBuffer, uint cbBufferLength);

		internal bool SetPNGIcon_64x64(IntPtr pvBuffer, uint cbBufferLength)
		{
			return _SetPNGIcon_64x64(Self, pvBuffer, cbBufferLength);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_EnablePlayPrevious")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _EnablePlayPrevious(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bValue);

		internal bool EnablePlayPrevious([MarshalAs(UnmanagedType.U1)] bool bValue)
		{
			return _EnablePlayPrevious(Self, bValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_EnablePlayNext")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _EnablePlayNext(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bValue);

		internal bool EnablePlayNext([MarshalAs(UnmanagedType.U1)] bool bValue)
		{
			return _EnablePlayNext(Self, bValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_EnableShuffled")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _EnableShuffled(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bValue);

		internal bool EnableShuffled([MarshalAs(UnmanagedType.U1)] bool bValue)
		{
			return _EnableShuffled(Self, bValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_EnableLooped")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _EnableLooped(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bValue);

		internal bool EnableLooped([MarshalAs(UnmanagedType.U1)] bool bValue)
		{
			return _EnableLooped(Self, bValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_EnableQueue")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _EnableQueue(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bValue);

		internal bool EnableQueue([MarshalAs(UnmanagedType.U1)] bool bValue)
		{
			return _EnableQueue(Self, bValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_EnablePlaylists")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _EnablePlaylists(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bValue);

		internal bool EnablePlaylists([MarshalAs(UnmanagedType.U1)] bool bValue)
		{
			return _EnablePlaylists(Self, bValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_UpdatePlaybackStatus")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _UpdatePlaybackStatus(IntPtr self, MusicStatus nStatus);

		internal bool UpdatePlaybackStatus(MusicStatus nStatus)
		{
			return _UpdatePlaybackStatus(Self, nStatus);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_UpdateShuffled")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _UpdateShuffled(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bValue);

		internal bool UpdateShuffled([MarshalAs(UnmanagedType.U1)] bool bValue)
		{
			return _UpdateShuffled(Self, bValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_UpdateLooped")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _UpdateLooped(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bValue);

		internal bool UpdateLooped([MarshalAs(UnmanagedType.U1)] bool bValue)
		{
			return _UpdateLooped(Self, bValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_UpdateVolume")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _UpdateVolume(IntPtr self, float flValue);

		internal bool UpdateVolume(float flValue)
		{
			return _UpdateVolume(Self, flValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_CurrentEntryWillChange")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _CurrentEntryWillChange(IntPtr self);

		internal bool CurrentEntryWillChange()
		{
			return _CurrentEntryWillChange(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_CurrentEntryIsAvailable")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _CurrentEntryIsAvailable(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bAvailable);

		internal bool CurrentEntryIsAvailable([MarshalAs(UnmanagedType.U1)] bool bAvailable)
		{
			return _CurrentEntryIsAvailable(Self, bAvailable);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_UpdateCurrentEntryText")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _UpdateCurrentEntryText(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchText);

		internal bool UpdateCurrentEntryText([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchText)
		{
			return _UpdateCurrentEntryText(Self, pchText);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_UpdateCurrentEntryElapsedSeconds")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _UpdateCurrentEntryElapsedSeconds(IntPtr self, int nValue);

		internal bool UpdateCurrentEntryElapsedSeconds(int nValue)
		{
			return _UpdateCurrentEntryElapsedSeconds(Self, nValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_UpdateCurrentEntryCoverArt")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _UpdateCurrentEntryCoverArt(IntPtr self, IntPtr pvBuffer, uint cbBufferLength);

		internal bool UpdateCurrentEntryCoverArt(IntPtr pvBuffer, uint cbBufferLength)
		{
			return _UpdateCurrentEntryCoverArt(Self, pvBuffer, cbBufferLength);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_CurrentEntryDidChange")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _CurrentEntryDidChange(IntPtr self);

		internal bool CurrentEntryDidChange()
		{
			return _CurrentEntryDidChange(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_QueueWillChange")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _QueueWillChange(IntPtr self);

		internal bool QueueWillChange()
		{
			return _QueueWillChange(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_ResetQueueEntries")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ResetQueueEntries(IntPtr self);

		internal bool ResetQueueEntries()
		{
			return _ResetQueueEntries(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_SetQueueEntry")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetQueueEntry(IntPtr self, int nID, int nPosition, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchEntryText);

		internal bool SetQueueEntry(int nID, int nPosition, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchEntryText)
		{
			return _SetQueueEntry(Self, nID, nPosition, pchEntryText);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_SetCurrentQueueEntry")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetCurrentQueueEntry(IntPtr self, int nID);

		internal bool SetCurrentQueueEntry(int nID)
		{
			return _SetCurrentQueueEntry(Self, nID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_QueueDidChange")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _QueueDidChange(IntPtr self);

		internal bool QueueDidChange()
		{
			return _QueueDidChange(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_PlaylistWillChange")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _PlaylistWillChange(IntPtr self);

		internal bool PlaylistWillChange()
		{
			return _PlaylistWillChange(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_ResetPlaylistEntries")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ResetPlaylistEntries(IntPtr self);

		internal bool ResetPlaylistEntries()
		{
			return _ResetPlaylistEntries(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_SetPlaylistEntry")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetPlaylistEntry(IntPtr self, int nID, int nPosition, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchEntryText);

		internal bool SetPlaylistEntry(int nID, int nPosition, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchEntryText)
		{
			return _SetPlaylistEntry(Self, nID, nPosition, pchEntryText);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_SetCurrentPlaylistEntry")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetCurrentPlaylistEntry(IntPtr self, int nID);

		internal bool SetCurrentPlaylistEntry(int nID)
		{
			return _SetCurrentPlaylistEntry(Self, nID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamMusicRemote_PlaylistDidChange")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _PlaylistDidChange(IntPtr self);

		internal bool PlaylistDidChange()
		{
			return _PlaylistDidChange(Self);
		}
	}
	internal class ISteamNetworking : SteamInterface
	{
		internal ISteamNetworking(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamNetworking_v006();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamNetworking_v006();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamGameServerNetworking_v006();

		public override IntPtr GetServerInterfacePointer()
		{
			return SteamAPI_SteamGameServerNetworking_v006();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworking_SendP2PPacket")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SendP2PPacket(IntPtr self, SteamId steamIDRemote, IntPtr pubData, uint cubData, P2PSend eP2PSendType, int nChannel);

		internal bool SendP2PPacket(SteamId steamIDRemote, IntPtr pubData, uint cubData, P2PSend eP2PSendType, int nChannel)
		{
			return _SendP2PPacket(Self, steamIDRemote, pubData, cubData, eP2PSendType, nChannel);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworking_IsP2PPacketAvailable")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsP2PPacketAvailable(IntPtr self, ref uint pcubMsgSize, int nChannel);

		internal bool IsP2PPacketAvailable(ref uint pcubMsgSize, int nChannel)
		{
			return _IsP2PPacketAvailable(Self, ref pcubMsgSize, nChannel);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworking_ReadP2PPacket")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ReadP2PPacket(IntPtr self, IntPtr pubDest, uint cubDest, ref uint pcubMsgSize, ref SteamId psteamIDRemote, int nChannel);

		internal bool ReadP2PPacket(IntPtr pubDest, uint cubDest, ref uint pcubMsgSize, ref SteamId psteamIDRemote, int nChannel)
		{
			return _ReadP2PPacket(Self, pubDest, cubDest, ref pcubMsgSize, ref psteamIDRemote, nChannel);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworking_AcceptP2PSessionWithUser")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _AcceptP2PSessionWithUser(IntPtr self, SteamId steamIDRemote);

		internal bool AcceptP2PSessionWithUser(SteamId steamIDRemote)
		{
			return _AcceptP2PSessionWithUser(Self, steamIDRemote);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworking_CloseP2PSessionWithUser")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _CloseP2PSessionWithUser(IntPtr self, SteamId steamIDRemote);

		internal bool CloseP2PSessionWithUser(SteamId steamIDRemote)
		{
			return _CloseP2PSessionWithUser(Self, steamIDRemote);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworking_CloseP2PChannelWithUser")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _CloseP2PChannelWithUser(IntPtr self, SteamId steamIDRemote, int nChannel);

		internal bool CloseP2PChannelWithUser(SteamId steamIDRemote, int nChannel)
		{
			return _CloseP2PChannelWithUser(Self, steamIDRemote, nChannel);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworking_GetP2PSessionState")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetP2PSessionState(IntPtr self, SteamId steamIDRemote, ref P2PSessionState_t pConnectionState);

		internal bool GetP2PSessionState(SteamId steamIDRemote, ref P2PSessionState_t pConnectionState)
		{
			return _GetP2PSessionState(Self, steamIDRemote, ref pConnectionState);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworking_AllowP2PPacketRelay")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _AllowP2PPacketRelay(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bAllow);

		internal bool AllowP2PPacketRelay([MarshalAs(UnmanagedType.U1)] bool bAllow)
		{
			return _AllowP2PPacketRelay(Self, bAllow);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworking_CreateP2PConnectionSocket")]
		private static extern SNetSocket_t _CreateP2PConnectionSocket(IntPtr self, SteamId steamIDTarget, int nVirtualPort, int nTimeoutSec, [MarshalAs(UnmanagedType.U1)] bool bAllowUseOfPacketRelay);

		internal SNetSocket_t CreateP2PConnectionSocket(SteamId steamIDTarget, int nVirtualPort, int nTimeoutSec, [MarshalAs(UnmanagedType.U1)] bool bAllowUseOfPacketRelay)
		{
			return _CreateP2PConnectionSocket(Self, steamIDTarget, nVirtualPort, nTimeoutSec, bAllowUseOfPacketRelay);
		}
	}
	internal class ISteamNetworkingConnectionCustomSignaling : SteamInterface
	{
		internal ISteamNetworkingConnectionCustomSignaling(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingConnectionCustomSignaling_SendSignal")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SendSignal(IntPtr self, Connection hConn, ref ConnectionInfo info, IntPtr pMsg, int cbMsg);

		internal bool SendSignal(Connection hConn, ref ConnectionInfo info, IntPtr pMsg, int cbMsg)
		{
			return _SendSignal(Self, hConn, ref info, pMsg, cbMsg);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingConnectionCustomSignaling_Release")]
		private static extern void _Release(IntPtr self);

		internal void Release()
		{
			_Release(Self);
		}
	}
	internal class ISteamNetworkingCustomSignalingRecvContext : SteamInterface
	{
		internal ISteamNetworkingCustomSignalingRecvContext(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingCustomSignalingRecvContext_OnConnectRequest")]
		private static extern IntPtr _OnConnectRequest(IntPtr self, Connection hConn, ref NetIdentity identityPeer);

		internal IntPtr OnConnectRequest(Connection hConn, ref NetIdentity identityPeer)
		{
			return _OnConnectRequest(Self, hConn, ref identityPeer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingCustomSignalingRecvContext_SendRejectionSignal")]
		private static extern void _SendRejectionSignal(IntPtr self, ref NetIdentity identityPeer, IntPtr pMsg, int cbMsg);

		internal void SendRejectionSignal(ref NetIdentity identityPeer, IntPtr pMsg, int cbMsg)
		{
			_SendRejectionSignal(Self, ref identityPeer, pMsg, cbMsg);
		}
	}
	internal class ISteamNetworkingSockets : SteamInterface
	{
		internal ISteamNetworkingSockets(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamNetworkingSockets_v008();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamNetworkingSockets_v008();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamGameServerNetworkingSockets_v008();

		public override IntPtr GetServerInterfacePointer()
		{
			return SteamAPI_SteamGameServerNetworkingSockets_v008();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP")]
		private static extern Steamworks.Data.Socket _CreateListenSocketIP(IntPtr self, ref NetAddress localAddress, int nOptions, [In][Out] NetKeyValue[] pOptions);

		internal Steamworks.Data.Socket CreateListenSocketIP(ref NetAddress localAddress, int nOptions, [In][Out] NetKeyValue[] pOptions)
		{
			return _CreateListenSocketIP(Self, ref localAddress, nOptions, pOptions);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress")]
		private static extern Connection _ConnectByIPAddress(IntPtr self, ref NetAddress address, int nOptions, [In][Out] NetKeyValue[] pOptions);

		internal Connection ConnectByIPAddress(ref NetAddress address, int nOptions, [In][Out] NetKeyValue[] pOptions)
		{
			return _ConnectByIPAddress(Self, ref address, nOptions, pOptions);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2P")]
		private static extern Steamworks.Data.Socket _CreateListenSocketP2P(IntPtr self, int nVirtualPort, int nOptions, [In][Out] NetKeyValue[] pOptions);

		internal Steamworks.Data.Socket CreateListenSocketP2P(int nVirtualPort, int nOptions, [In][Out] NetKeyValue[] pOptions)
		{
			return _CreateListenSocketP2P(Self, nVirtualPort, nOptions, pOptions);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ConnectP2P")]
		private static extern Connection _ConnectP2P(IntPtr self, ref NetIdentity identityRemote, int nVirtualPort, int nOptions, [In][Out] NetKeyValue[] pOptions);

		internal Connection ConnectP2P(ref NetIdentity identityRemote, int nVirtualPort, int nOptions, [In][Out] NetKeyValue[] pOptions)
		{
			return _ConnectP2P(Self, ref identityRemote, nVirtualPort, nOptions, pOptions);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_AcceptConnection")]
		private static extern Result _AcceptConnection(IntPtr self, Connection hConn);

		internal Result AcceptConnection(Connection hConn)
		{
			return _AcceptConnection(Self, hConn);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_CloseConnection")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _CloseConnection(IntPtr self, Connection hPeer, int nReason, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszDebug, [MarshalAs(UnmanagedType.U1)] bool bEnableLinger);

		internal bool CloseConnection(Connection hPeer, int nReason, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszDebug, [MarshalAs(UnmanagedType.U1)] bool bEnableLinger)
		{
			return _CloseConnection(Self, hPeer, nReason, pszDebug, bEnableLinger);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_CloseListenSocket")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _CloseListenSocket(IntPtr self, Steamworks.Data.Socket hSocket);

		internal bool CloseListenSocket(Steamworks.Data.Socket hSocket)
		{
			return _CloseListenSocket(Self, hSocket);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_SetConnectionUserData")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetConnectionUserData(IntPtr self, Connection hPeer, long nUserData);

		internal bool SetConnectionUserData(Connection hPeer, long nUserData)
		{
			return _SetConnectionUserData(Self, hPeer, nUserData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetConnectionUserData")]
		private static extern long _GetConnectionUserData(IntPtr self, Connection hPeer);

		internal long GetConnectionUserData(Connection hPeer)
		{
			return _GetConnectionUserData(Self, hPeer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_SetConnectionName")]
		private static extern void _SetConnectionName(IntPtr self, Connection hPeer, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszName);

		internal void SetConnectionName(Connection hPeer, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszName)
		{
			_SetConnectionName(Self, hPeer, pszName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetConnectionName")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetConnectionName(IntPtr self, Connection hPeer, IntPtr pszName, int nMaxLen);

		internal bool GetConnectionName(Connection hPeer, out string pszName)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _GetConnectionName(Self, hPeer, intPtr, 32768);
			pszName = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_SendMessageToConnection")]
		private static extern Result _SendMessageToConnection(IntPtr self, Connection hConn, IntPtr pData, uint cbData, int nSendFlags, ref long pOutMessageNumber);

		internal Result SendMessageToConnection(Connection hConn, IntPtr pData, uint cbData, int nSendFlags, ref long pOutMessageNumber)
		{
			return _SendMessageToConnection(Self, hConn, pData, cbData, nSendFlags, ref pOutMessageNumber);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_SendMessages")]
		private static extern void _SendMessages(IntPtr self, int nMessages, ref NetMsg pMessages, [In][Out] long[] pOutMessageNumberOrResult);

		internal void SendMessages(int nMessages, ref NetMsg pMessages, [In][Out] long[] pOutMessageNumberOrResult)
		{
			_SendMessages(Self, nMessages, ref pMessages, pOutMessageNumberOrResult);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_FlushMessagesOnConnection")]
		private static extern Result _FlushMessagesOnConnection(IntPtr self, Connection hConn);

		internal Result FlushMessagesOnConnection(Connection hConn)
		{
			return _FlushMessagesOnConnection(Self, hConn);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection")]
		private static extern int _ReceiveMessagesOnConnection(IntPtr self, Connection hConn, IntPtr ppOutMessages, int nMaxMessages);

		internal int ReceiveMessagesOnConnection(Connection hConn, IntPtr ppOutMessages, int nMaxMessages)
		{
			return _ReceiveMessagesOnConnection(Self, hConn, ppOutMessages, nMaxMessages);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetConnectionInfo")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetConnectionInfo(IntPtr self, Connection hConn, ref ConnectionInfo pInfo);

		internal bool GetConnectionInfo(Connection hConn, ref ConnectionInfo pInfo)
		{
			return _GetConnectionInfo(Self, hConn, ref pInfo);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetQuickConnectionStatus")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetQuickConnectionStatus(IntPtr self, Connection hConn, ref SteamNetworkingQuickConnectionStatus pStats);

		internal bool GetQuickConnectionStatus(Connection hConn, ref SteamNetworkingQuickConnectionStatus pStats)
		{
			return _GetQuickConnectionStatus(Self, hConn, ref pStats);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetDetailedConnectionStatus")]
		private static extern int _GetDetailedConnectionStatus(IntPtr self, Connection hConn, IntPtr pszBuf, int cbBuf);

		internal int GetDetailedConnectionStatus(Connection hConn, out string pszBuf)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			int result = _GetDetailedConnectionStatus(Self, hConn, intPtr, 32768);
			pszBuf = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetListenSocketAddress")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetListenSocketAddress(IntPtr self, Steamworks.Data.Socket hSocket, ref NetAddress address);

		internal bool GetListenSocketAddress(Steamworks.Data.Socket hSocket, ref NetAddress address)
		{
			return _GetListenSocketAddress(Self, hSocket, ref address);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_CreateSocketPair")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _CreateSocketPair(IntPtr self, [In][Out] Connection[] pOutConnection1, [In][Out] Connection[] pOutConnection2, [MarshalAs(UnmanagedType.U1)] bool bUseNetworkLoopback, ref NetIdentity pIdentity1, ref NetIdentity pIdentity2);

		internal bool CreateSocketPair([In][Out] Connection[] pOutConnection1, [In][Out] Connection[] pOutConnection2, [MarshalAs(UnmanagedType.U1)] bool bUseNetworkLoopback, ref NetIdentity pIdentity1, ref NetIdentity pIdentity2)
		{
			return _CreateSocketPair(Self, pOutConnection1, pOutConnection2, bUseNetworkLoopback, ref pIdentity1, ref pIdentity2);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetIdentity")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetIdentity(IntPtr self, ref NetIdentity pIdentity);

		internal bool GetIdentity(ref NetIdentity pIdentity)
		{
			return _GetIdentity(Self, ref pIdentity);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_InitAuthentication")]
		private static extern SteamNetworkingAvailability _InitAuthentication(IntPtr self);

		internal SteamNetworkingAvailability InitAuthentication()
		{
			return _InitAuthentication(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetAuthenticationStatus")]
		private static extern SteamNetworkingAvailability _GetAuthenticationStatus(IntPtr self, ref SteamNetAuthenticationStatus_t pDetails);

		internal SteamNetworkingAvailability GetAuthenticationStatus(ref SteamNetAuthenticationStatus_t pDetails)
		{
			return _GetAuthenticationStatus(Self, ref pDetails);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_CreatePollGroup")]
		private static extern HSteamNetPollGroup _CreatePollGroup(IntPtr self);

		internal HSteamNetPollGroup CreatePollGroup()
		{
			return _CreatePollGroup(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_DestroyPollGroup")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _DestroyPollGroup(IntPtr self, HSteamNetPollGroup hPollGroup);

		internal bool DestroyPollGroup(HSteamNetPollGroup hPollGroup)
		{
			return _DestroyPollGroup(Self, hPollGroup);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetConnectionPollGroup(IntPtr self, Connection hConn, HSteamNetPollGroup hPollGroup);

		internal bool SetConnectionPollGroup(Connection hConn, HSteamNetPollGroup hPollGroup)
		{
			return _SetConnectionPollGroup(Self, hConn, hPollGroup);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnPollGroup")]
		private static extern int _ReceiveMessagesOnPollGroup(IntPtr self, HSteamNetPollGroup hPollGroup, IntPtr ppOutMessages, int nMaxMessages);

		internal int ReceiveMessagesOnPollGroup(HSteamNetPollGroup hPollGroup, IntPtr ppOutMessages, int nMaxMessages)
		{
			return _ReceiveMessagesOnPollGroup(Self, hPollGroup, ppOutMessages, nMaxMessages);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ReceivedRelayAuthTicket")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ReceivedRelayAuthTicket(IntPtr self, IntPtr pvTicket, int cbTicket, [In][Out] SteamDatagramRelayAuthTicket[] pOutParsedTicket);

		internal bool ReceivedRelayAuthTicket(IntPtr pvTicket, int cbTicket, [In][Out] SteamDatagramRelayAuthTicket[] pOutParsedTicket)
		{
			return _ReceivedRelayAuthTicket(Self, pvTicket, cbTicket, pOutParsedTicket);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_FindRelayAuthTicketForServer")]
		private static extern int _FindRelayAuthTicketForServer(IntPtr self, ref NetIdentity identityGameServer, int nVirtualPort, [In][Out] SteamDatagramRelayAuthTicket[] pOutParsedTicket);

		internal int FindRelayAuthTicketForServer(ref NetIdentity identityGameServer, int nVirtualPort, [In][Out] SteamDatagramRelayAuthTicket[] pOutParsedTicket)
		{
			return _FindRelayAuthTicketForServer(Self, ref identityGameServer, nVirtualPort, pOutParsedTicket);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ConnectToHostedDedicatedServer")]
		private static extern Connection _ConnectToHostedDedicatedServer(IntPtr self, ref NetIdentity identityTarget, int nVirtualPort, int nOptions, [In][Out] NetKeyValue[] pOptions);

		internal Connection ConnectToHostedDedicatedServer(ref NetIdentity identityTarget, int nVirtualPort, int nOptions, [In][Out] NetKeyValue[] pOptions)
		{
			return _ConnectToHostedDedicatedServer(Self, ref identityTarget, nVirtualPort, nOptions, pOptions);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPort")]
		private static extern ushort _GetHostedDedicatedServerPort(IntPtr self);

		internal ushort GetHostedDedicatedServerPort()
		{
			return _GetHostedDedicatedServerPort(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPOPID")]
		private static extern SteamNetworkingPOPID _GetHostedDedicatedServerPOPID(IntPtr self);

		internal SteamNetworkingPOPID GetHostedDedicatedServerPOPID()
		{
			return _GetHostedDedicatedServerPOPID(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerAddress")]
		private static extern Result _GetHostedDedicatedServerAddress(IntPtr self, ref SteamDatagramHostedAddress pRouting);

		internal Result GetHostedDedicatedServerAddress(ref SteamDatagramHostedAddress pRouting)
		{
			return _GetHostedDedicatedServerAddress(Self, ref pRouting);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_CreateHostedDedicatedServerListenSocket")]
		private static extern Steamworks.Data.Socket _CreateHostedDedicatedServerListenSocket(IntPtr self, int nVirtualPort, int nOptions, [In][Out] NetKeyValue[] pOptions);

		internal Steamworks.Data.Socket CreateHostedDedicatedServerListenSocket(int nVirtualPort, int nOptions, [In][Out] NetKeyValue[] pOptions)
		{
			return _CreateHostedDedicatedServerListenSocket(Self, nVirtualPort, nOptions, pOptions);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetGameCoordinatorServerLogin")]
		private static extern Result _GetGameCoordinatorServerLogin(IntPtr self, ref SteamDatagramGameCoordinatorServerLogin pLoginInfo, ref int pcbSignedBlob, IntPtr pBlob);

		internal Result GetGameCoordinatorServerLogin(ref SteamDatagramGameCoordinatorServerLogin pLoginInfo, ref int pcbSignedBlob, IntPtr pBlob)
		{
			return _GetGameCoordinatorServerLogin(Self, ref pLoginInfo, ref pcbSignedBlob, pBlob);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ConnectP2PCustomSignaling")]
		private static extern Connection _ConnectP2PCustomSignaling(IntPtr self, IntPtr pSignaling, ref NetIdentity pPeerIdentity, int nOptions, [In][Out] NetKeyValue[] pOptions);

		internal Connection ConnectP2PCustomSignaling(IntPtr pSignaling, ref NetIdentity pPeerIdentity, int nOptions, [In][Out] NetKeyValue[] pOptions)
		{
			return _ConnectP2PCustomSignaling(Self, pSignaling, ref pPeerIdentity, nOptions, pOptions);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ReceivedP2PCustomSignal")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ReceivedP2PCustomSignal(IntPtr self, IntPtr pMsg, int cbMsg, IntPtr pContext);

		internal bool ReceivedP2PCustomSignal(IntPtr pMsg, int cbMsg, IntPtr pContext)
		{
			return _ReceivedP2PCustomSignal(Self, pMsg, cbMsg, pContext);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetCertificateRequest")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetCertificateRequest(IntPtr self, ref int pcbBlob, IntPtr pBlob, ref NetErrorMessage errMsg);

		internal bool GetCertificateRequest(ref int pcbBlob, IntPtr pBlob, ref NetErrorMessage errMsg)
		{
			return _GetCertificateRequest(Self, ref pcbBlob, pBlob, ref errMsg);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingSockets_SetCertificate")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetCertificate(IntPtr self, IntPtr pCertificate, int cbCertificate, ref NetErrorMessage errMsg);

		internal bool SetCertificate(IntPtr pCertificate, int cbCertificate, ref NetErrorMessage errMsg)
		{
			return _SetCertificate(Self, pCertificate, cbCertificate, ref errMsg);
		}
	}
	internal class ISteamNetworkingUtils : SteamInterface
	{
		internal ISteamNetworkingUtils(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamNetworkingUtils_v003();

		public override IntPtr GetGlobalInterfacePointer()
		{
			return SteamAPI_SteamNetworkingUtils_v003();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_AllocateMessage")]
		private static extern IntPtr _AllocateMessage(IntPtr self, int cbAllocateBuffer);

		internal NetMsg AllocateMessage(int cbAllocateBuffer)
		{
			return _AllocateMessage(Self, cbAllocateBuffer).ToType<NetMsg>();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_InitRelayNetworkAccess")]
		private static extern void _InitRelayNetworkAccess(IntPtr self);

		internal void InitRelayNetworkAccess()
		{
			_InitRelayNetworkAccess(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetRelayNetworkStatus")]
		private static extern SteamNetworkingAvailability _GetRelayNetworkStatus(IntPtr self, ref SteamRelayNetworkStatus_t pDetails);

		internal SteamNetworkingAvailability GetRelayNetworkStatus(ref SteamRelayNetworkStatus_t pDetails)
		{
			return _GetRelayNetworkStatus(Self, ref pDetails);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetLocalPingLocation")]
		private static extern float _GetLocalPingLocation(IntPtr self, ref NetPingLocation result);

		internal float GetLocalPingLocation(ref NetPingLocation result)
		{
			return _GetLocalPingLocation(Self, ref result);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_EstimatePingTimeBetweenTwoLocations")]
		private static extern int _EstimatePingTimeBetweenTwoLocations(IntPtr self, ref NetPingLocation location1, ref NetPingLocation location2);

		internal int EstimatePingTimeBetweenTwoLocations(ref NetPingLocation location1, ref NetPingLocation location2)
		{
			return _EstimatePingTimeBetweenTwoLocations(Self, ref location1, ref location2);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_EstimatePingTimeFromLocalHost")]
		private static extern int _EstimatePingTimeFromLocalHost(IntPtr self, ref NetPingLocation remoteLocation);

		internal int EstimatePingTimeFromLocalHost(ref NetPingLocation remoteLocation)
		{
			return _EstimatePingTimeFromLocalHost(Self, ref remoteLocation);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_ConvertPingLocationToString")]
		private static extern void _ConvertPingLocationToString(IntPtr self, ref NetPingLocation location, IntPtr pszBuf, int cchBufSize);

		internal void ConvertPingLocationToString(ref NetPingLocation location, out string pszBuf)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			_ConvertPingLocationToString(Self, ref location, intPtr, 32768);
			pszBuf = Helpers.MemoryToString(intPtr);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_ParsePingLocationString")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ParsePingLocationString(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszString, ref NetPingLocation result);

		internal bool ParsePingLocationString([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszString, ref NetPingLocation result)
		{
			return _ParsePingLocationString(Self, pszString, ref result);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_CheckPingDataUpToDate")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _CheckPingDataUpToDate(IntPtr self, float flMaxAgeSeconds);

		internal bool CheckPingDataUpToDate(float flMaxAgeSeconds)
		{
			return _CheckPingDataUpToDate(Self, flMaxAgeSeconds);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetPingToDataCenter")]
		private static extern int _GetPingToDataCenter(IntPtr self, SteamNetworkingPOPID popID, ref SteamNetworkingPOPID pViaRelayPoP);

		internal int GetPingToDataCenter(SteamNetworkingPOPID popID, ref SteamNetworkingPOPID pViaRelayPoP)
		{
			return _GetPingToDataCenter(Self, popID, ref pViaRelayPoP);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetDirectPingToPOP")]
		private static extern int _GetDirectPingToPOP(IntPtr self, SteamNetworkingPOPID popID);

		internal int GetDirectPingToPOP(SteamNetworkingPOPID popID)
		{
			return _GetDirectPingToPOP(Self, popID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetPOPCount")]
		private static extern int _GetPOPCount(IntPtr self);

		internal int GetPOPCount()
		{
			return _GetPOPCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetPOPList")]
		private static extern int _GetPOPList(IntPtr self, ref SteamNetworkingPOPID list, int nListSz);

		internal int GetPOPList(ref SteamNetworkingPOPID list, int nListSz)
		{
			return _GetPOPList(Self, ref list, nListSz);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetLocalTimestamp")]
		private static extern long _GetLocalTimestamp(IntPtr self);

		internal long GetLocalTimestamp()
		{
			return _GetLocalTimestamp(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetDebugOutputFunction")]
		private static extern void _SetDebugOutputFunction(IntPtr self, NetDebugOutput eDetailLevel, NetDebugFunc pfnFunc);

		internal void SetDebugOutputFunction(NetDebugOutput eDetailLevel, NetDebugFunc pfnFunc)
		{
			_SetDebugOutputFunction(Self, eDetailLevel, pfnFunc);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueInt32")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetGlobalConfigValueInt32(IntPtr self, NetConfig eValue, int val);

		internal bool SetGlobalConfigValueInt32(NetConfig eValue, int val)
		{
			return _SetGlobalConfigValueInt32(Self, eValue, val);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueFloat")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetGlobalConfigValueFloat(IntPtr self, NetConfig eValue, float val);

		internal bool SetGlobalConfigValueFloat(NetConfig eValue, float val)
		{
			return _SetGlobalConfigValueFloat(Self, eValue, val);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueString")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetGlobalConfigValueString(IntPtr self, NetConfig eValue, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string val);

		internal bool SetGlobalConfigValueString(NetConfig eValue, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string val)
		{
			return _SetGlobalConfigValueString(Self, eValue, val);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueInt32")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetConnectionConfigValueInt32(IntPtr self, Connection hConn, NetConfig eValue, int val);

		internal bool SetConnectionConfigValueInt32(Connection hConn, NetConfig eValue, int val)
		{
			return _SetConnectionConfigValueInt32(Self, hConn, eValue, val);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueFloat")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetConnectionConfigValueFloat(IntPtr self, Connection hConn, NetConfig eValue, float val);

		internal bool SetConnectionConfigValueFloat(Connection hConn, NetConfig eValue, float val)
		{
			return _SetConnectionConfigValueFloat(Self, hConn, eValue, val);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueString")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetConnectionConfigValueString(IntPtr self, Connection hConn, NetConfig eValue, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string val);

		internal bool SetConnectionConfigValueString(Connection hConn, NetConfig eValue, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string val)
		{
			return _SetConnectionConfigValueString(Self, hConn, eValue, val);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetConfigValue")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetConfigValue(IntPtr self, NetConfig eValue, NetConfigScope eScopeType, IntPtr scopeObj, NetConfigType eDataType, IntPtr pArg);

		internal bool SetConfigValue(NetConfig eValue, NetConfigScope eScopeType, IntPtr scopeObj, NetConfigType eDataType, IntPtr pArg)
		{
			return _SetConfigValue(Self, eValue, eScopeType, scopeObj, eDataType, pArg);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetConfigValueStruct")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetConfigValueStruct(IntPtr self, ref NetKeyValue opt, NetConfigScope eScopeType, IntPtr scopeObj);

		internal bool SetConfigValueStruct(ref NetKeyValue opt, NetConfigScope eScopeType, IntPtr scopeObj)
		{
			return _SetConfigValueStruct(Self, ref opt, eScopeType, scopeObj);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetConfigValue")]
		private static extern NetConfigResult _GetConfigValue(IntPtr self, NetConfig eValue, NetConfigScope eScopeType, IntPtr scopeObj, ref NetConfigType pOutDataType, IntPtr pResult, ref UIntPtr cbResult);

		internal NetConfigResult GetConfigValue(NetConfig eValue, NetConfigScope eScopeType, IntPtr scopeObj, ref NetConfigType pOutDataType, IntPtr pResult, ref UIntPtr cbResult)
		{
			return _GetConfigValue(Self, eValue, eScopeType, scopeObj, ref pOutDataType, pResult, ref cbResult);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetConfigValueInfo")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetConfigValueInfo(IntPtr self, NetConfig eValue, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pOutName, ref NetConfigType pOutDataType, [In][Out] NetConfigScope[] pOutScope, [In][Out] NetConfig[] pOutNextValue);

		internal bool GetConfigValueInfo(NetConfig eValue, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pOutName, ref NetConfigType pOutDataType, [In][Out] NetConfigScope[] pOutScope, [In][Out] NetConfig[] pOutNextValue)
		{
			return _GetConfigValueInfo(Self, eValue, pOutName, ref pOutDataType, pOutScope, pOutNextValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetFirstConfigValue")]
		private static extern NetConfig _GetFirstConfigValue(IntPtr self);

		internal NetConfig GetFirstConfigValue()
		{
			return _GetFirstConfigValue(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ToString")]
		private static extern void _SteamNetworkingIPAddr_ToString(IntPtr self, ref NetAddress addr, IntPtr buf, uint cbBuf, [MarshalAs(UnmanagedType.U1)] bool bWithPort);

		internal void SteamNetworkingIPAddr_ToString(ref NetAddress addr, out string buf, [MarshalAs(UnmanagedType.U1)] bool bWithPort)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			_SteamNetworkingIPAddr_ToString(Self, ref addr, intPtr, 32768u, bWithPort);
			buf = Helpers.MemoryToString(intPtr);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ParseString")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SteamNetworkingIPAddr_ParseString(IntPtr self, ref NetAddress pAddr, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszStr);

		internal bool SteamNetworkingIPAddr_ParseString(ref NetAddress pAddr, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszStr)
		{
			return _SteamNetworkingIPAddr_ParseString(Self, ref pAddr, pszStr);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ToString")]
		private static extern void _SteamNetworkingIdentity_ToString(IntPtr self, ref NetIdentity identity, IntPtr buf, uint cbBuf);

		internal void SteamNetworkingIdentity_ToString(ref NetIdentity identity, out string buf)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			_SteamNetworkingIdentity_ToString(Self, ref identity, intPtr, 32768u);
			buf = Helpers.MemoryToString(intPtr);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ParseString")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SteamNetworkingIdentity_ParseString(IntPtr self, ref NetIdentity pIdentity, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszStr);

		internal bool SteamNetworkingIdentity_ParseString(ref NetIdentity pIdentity, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszStr)
		{
			return _SteamNetworkingIdentity_ParseString(Self, ref pIdentity, pszStr);
		}
	}
	internal class ISteamParentalSettings : SteamInterface
	{
		internal ISteamParentalSettings(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamParentalSettings_v001();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamParentalSettings_v001();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParentalSettings_BIsParentalLockEnabled")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsParentalLockEnabled(IntPtr self);

		internal bool BIsParentalLockEnabled()
		{
			return _BIsParentalLockEnabled(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParentalSettings_BIsParentalLockLocked")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsParentalLockLocked(IntPtr self);

		internal bool BIsParentalLockLocked()
		{
			return _BIsParentalLockLocked(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParentalSettings_BIsAppBlocked")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsAppBlocked(IntPtr self, AppId nAppID);

		internal bool BIsAppBlocked(AppId nAppID)
		{
			return _BIsAppBlocked(Self, nAppID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParentalSettings_BIsAppInBlockList")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsAppInBlockList(IntPtr self, AppId nAppID);

		internal bool BIsAppInBlockList(AppId nAppID)
		{
			return _BIsAppInBlockList(Self, nAppID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParentalSettings_BIsFeatureBlocked")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsFeatureBlocked(IntPtr self, ParentalFeature eFeature);

		internal bool BIsFeatureBlocked(ParentalFeature eFeature)
		{
			return _BIsFeatureBlocked(Self, eFeature);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParentalSettings_BIsFeatureInBlockList")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsFeatureInBlockList(IntPtr self, ParentalFeature eFeature);

		internal bool BIsFeatureInBlockList(ParentalFeature eFeature)
		{
			return _BIsFeatureInBlockList(Self, eFeature);
		}
	}
	internal class ISteamParties : SteamInterface
	{
		internal ISteamParties(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamParties_v002();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamParties_v002();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParties_GetNumActiveBeacons")]
		private static extern uint _GetNumActiveBeacons(IntPtr self);

		internal uint GetNumActiveBeacons()
		{
			return _GetNumActiveBeacons(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParties_GetBeaconByIndex")]
		private static extern PartyBeaconID_t _GetBeaconByIndex(IntPtr self, uint unIndex);

		internal PartyBeaconID_t GetBeaconByIndex(uint unIndex)
		{
			return _GetBeaconByIndex(Self, unIndex);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParties_GetBeaconDetails")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetBeaconDetails(IntPtr self, PartyBeaconID_t ulBeaconID, ref SteamId pSteamIDBeaconOwner, ref SteamPartyBeaconLocation_t pLocation, IntPtr pchMetadata, int cchMetadata);

		internal bool GetBeaconDetails(PartyBeaconID_t ulBeaconID, ref SteamId pSteamIDBeaconOwner, ref SteamPartyBeaconLocation_t pLocation, out string pchMetadata)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _GetBeaconDetails(Self, ulBeaconID, ref pSteamIDBeaconOwner, ref pLocation, intPtr, 32768);
			pchMetadata = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParties_JoinParty")]
		private static extern SteamAPICall_t _JoinParty(IntPtr self, PartyBeaconID_t ulBeaconID);

		internal CallResult<JoinPartyCallback_t> JoinParty(PartyBeaconID_t ulBeaconID)
		{
			return new CallResult<JoinPartyCallback_t>(_JoinParty(Self, ulBeaconID), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParties_GetNumAvailableBeaconLocations")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetNumAvailableBeaconLocations(IntPtr self, ref uint puNumLocations);

		internal bool GetNumAvailableBeaconLocations(ref uint puNumLocations)
		{
			return _GetNumAvailableBeaconLocations(Self, ref puNumLocations);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParties_GetAvailableBeaconLocations")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetAvailableBeaconLocations(IntPtr self, ref SteamPartyBeaconLocation_t pLocationList, uint uMaxNumLocations);

		internal bool GetAvailableBeaconLocations(ref SteamPartyBeaconLocation_t pLocationList, uint uMaxNumLocations)
		{
			return _GetAvailableBeaconLocations(Self, ref pLocationList, uMaxNumLocations);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParties_CreateBeacon")]
		private static extern SteamAPICall_t _CreateBeacon(IntPtr self, uint unOpenSlots, ref SteamPartyBeaconLocation_t pBeaconLocation, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchConnectString, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchMetadata);

		internal CallResult<CreateBeaconCallback_t> CreateBeacon(uint unOpenSlots, SteamPartyBeaconLocation_t pBeaconLocation, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchConnectString, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchMetadata)
		{
			return new CallResult<CreateBeaconCallback_t>(_CreateBeacon(Self, unOpenSlots, ref pBeaconLocation, pchConnectString, pchMetadata), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParties_OnReservationCompleted")]
		private static extern void _OnReservationCompleted(IntPtr self, PartyBeaconID_t ulBeacon, SteamId steamIDUser);

		internal void OnReservationCompleted(PartyBeaconID_t ulBeacon, SteamId steamIDUser)
		{
			_OnReservationCompleted(Self, ulBeacon, steamIDUser);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParties_CancelReservation")]
		private static extern void _CancelReservation(IntPtr self, PartyBeaconID_t ulBeacon, SteamId steamIDUser);

		internal void CancelReservation(PartyBeaconID_t ulBeacon, SteamId steamIDUser)
		{
			_CancelReservation(Self, ulBeacon, steamIDUser);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParties_ChangeNumOpenSlots")]
		private static extern SteamAPICall_t _ChangeNumOpenSlots(IntPtr self, PartyBeaconID_t ulBeacon, uint unOpenSlots);

		internal CallResult<ChangeNumOpenSlotsCallback_t> ChangeNumOpenSlots(PartyBeaconID_t ulBeacon, uint unOpenSlots)
		{
			return new CallResult<ChangeNumOpenSlotsCallback_t>(_ChangeNumOpenSlots(Self, ulBeacon, unOpenSlots), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParties_DestroyBeacon")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _DestroyBeacon(IntPtr self, PartyBeaconID_t ulBeacon);

		internal bool DestroyBeacon(PartyBeaconID_t ulBeacon)
		{
			return _DestroyBeacon(Self, ulBeacon);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamParties_GetBeaconLocationData")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetBeaconLocationData(IntPtr self, SteamPartyBeaconLocation_t BeaconLocation, SteamPartyBeaconLocationData eData, IntPtr pchDataStringOut, int cchDataStringOut);

		internal bool GetBeaconLocationData(SteamPartyBeaconLocation_t BeaconLocation, SteamPartyBeaconLocationData eData, out string pchDataStringOut)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _GetBeaconLocationData(Self, BeaconLocation, eData, intPtr, 32768);
			pchDataStringOut = Helpers.MemoryToString(intPtr);
			return result;
		}
	}
	internal class ISteamRemotePlay : SteamInterface
	{
		internal ISteamRemotePlay(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamRemotePlay_v001();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamRemotePlay_v001();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemotePlay_GetSessionCount")]
		private static extern uint _GetSessionCount(IntPtr self);

		internal uint GetSessionCount()
		{
			return _GetSessionCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemotePlay_GetSessionID")]
		private static extern RemotePlaySessionID_t _GetSessionID(IntPtr self, int iSessionIndex);

		internal RemotePlaySessionID_t GetSessionID(int iSessionIndex)
		{
			return _GetSessionID(Self, iSessionIndex);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemotePlay_GetSessionSteamID")]
		private static extern SteamId _GetSessionSteamID(IntPtr self, RemotePlaySessionID_t unSessionID);

		internal SteamId GetSessionSteamID(RemotePlaySessionID_t unSessionID)
		{
			return _GetSessionSteamID(Self, unSessionID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemotePlay_GetSessionClientName")]
		private static extern Utf8StringPointer _GetSessionClientName(IntPtr self, RemotePlaySessionID_t unSessionID);

		internal string GetSessionClientName(RemotePlaySessionID_t unSessionID)
		{
			return _GetSessionClientName(Self, unSessionID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemotePlay_GetSessionClientFormFactor")]
		private static extern SteamDeviceFormFactor _GetSessionClientFormFactor(IntPtr self, RemotePlaySessionID_t unSessionID);

		internal SteamDeviceFormFactor GetSessionClientFormFactor(RemotePlaySessionID_t unSessionID)
		{
			return _GetSessionClientFormFactor(Self, unSessionID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemotePlay_BGetSessionClientResolution")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BGetSessionClientResolution(IntPtr self, RemotePlaySessionID_t unSessionID, ref int pnResolutionX, ref int pnResolutionY);

		internal bool BGetSessionClientResolution(RemotePlaySessionID_t unSessionID, ref int pnResolutionX, ref int pnResolutionY)
		{
			return _BGetSessionClientResolution(Self, unSessionID, ref pnResolutionX, ref pnResolutionY);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemotePlay_BSendRemotePlayTogetherInvite")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BSendRemotePlayTogetherInvite(IntPtr self, SteamId steamIDFriend);

		internal bool BSendRemotePlayTogetherInvite(SteamId steamIDFriend)
		{
			return _BSendRemotePlayTogetherInvite(Self, steamIDFriend);
		}
	}
	internal class ISteamRemoteStorage : SteamInterface
	{
		internal ISteamRemoteStorage(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamRemoteStorage_v014();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamRemoteStorage_v014();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_FileWrite")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _FileWrite(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile, IntPtr pvData, int cubData);

		internal bool FileWrite([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile, IntPtr pvData, int cubData)
		{
			return _FileWrite(Self, pchFile, pvData, cubData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_FileRead")]
		private static extern int _FileRead(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile, IntPtr pvData, int cubDataToRead);

		internal int FileRead([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile, IntPtr pvData, int cubDataToRead)
		{
			return _FileRead(Self, pchFile, pvData, cubDataToRead);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_FileWriteAsync")]
		private static extern SteamAPICall_t _FileWriteAsync(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile, IntPtr pvData, uint cubData);

		internal CallResult<RemoteStorageFileWriteAsyncComplete_t> FileWriteAsync([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile, IntPtr pvData, uint cubData)
		{
			return new CallResult<RemoteStorageFileWriteAsyncComplete_t>(_FileWriteAsync(Self, pchFile, pvData, cubData), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_FileReadAsync")]
		private static extern SteamAPICall_t _FileReadAsync(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile, uint nOffset, uint cubToRead);

		internal CallResult<RemoteStorageFileReadAsyncComplete_t> FileReadAsync([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile, uint nOffset, uint cubToRead)
		{
			return new CallResult<RemoteStorageFileReadAsyncComplete_t>(_FileReadAsync(Self, pchFile, nOffset, cubToRead), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_FileReadAsyncComplete")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _FileReadAsyncComplete(IntPtr self, SteamAPICall_t hReadCall, IntPtr pvBuffer, uint cubToRead);

		internal bool FileReadAsyncComplete(SteamAPICall_t hReadCall, IntPtr pvBuffer, uint cubToRead)
		{
			return _FileReadAsyncComplete(Self, hReadCall, pvBuffer, cubToRead);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_FileForget")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _FileForget(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile);

		internal bool FileForget([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile)
		{
			return _FileForget(Self, pchFile);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_FileDelete")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _FileDelete(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile);

		internal bool FileDelete([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile)
		{
			return _FileDelete(Self, pchFile);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_FileShare")]
		private static extern SteamAPICall_t _FileShare(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile);

		internal CallResult<RemoteStorageFileShareResult_t> FileShare([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile)
		{
			return new CallResult<RemoteStorageFileShareResult_t>(_FileShare(Self, pchFile), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_SetSyncPlatforms")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetSyncPlatforms(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile, RemoteStoragePlatform eRemoteStoragePlatform);

		internal bool SetSyncPlatforms([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile, RemoteStoragePlatform eRemoteStoragePlatform)
		{
			return _SetSyncPlatforms(Self, pchFile, eRemoteStoragePlatform);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_FileWriteStreamOpen")]
		private static extern UGCFileWriteStreamHandle_t _FileWriteStreamOpen(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile);

		internal UGCFileWriteStreamHandle_t FileWriteStreamOpen([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile)
		{
			return _FileWriteStreamOpen(Self, pchFile);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_FileWriteStreamWriteChunk")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _FileWriteStreamWriteChunk(IntPtr self, UGCFileWriteStreamHandle_t writeHandle, IntPtr pvData, int cubData);

		internal bool FileWriteStreamWriteChunk(UGCFileWriteStreamHandle_t writeHandle, IntPtr pvData, int cubData)
		{
			return _FileWriteStreamWriteChunk(Self, writeHandle, pvData, cubData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_FileWriteStreamClose")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _FileWriteStreamClose(IntPtr self, UGCFileWriteStreamHandle_t writeHandle);

		internal bool FileWriteStreamClose(UGCFileWriteStreamHandle_t writeHandle)
		{
			return _FileWriteStreamClose(Self, writeHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_FileWriteStreamCancel")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _FileWriteStreamCancel(IntPtr self, UGCFileWriteStreamHandle_t writeHandle);

		internal bool FileWriteStreamCancel(UGCFileWriteStreamHandle_t writeHandle)
		{
			return _FileWriteStreamCancel(Self, writeHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_FileExists")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _FileExists(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile);

		internal bool FileExists([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile)
		{
			return _FileExists(Self, pchFile);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_FilePersisted")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _FilePersisted(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile);

		internal bool FilePersisted([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile)
		{
			return _FilePersisted(Self, pchFile);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_GetFileSize")]
		private static extern int _GetFileSize(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile);

		internal int GetFileSize([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile)
		{
			return _GetFileSize(Self, pchFile);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_GetFileTimestamp")]
		private static extern long _GetFileTimestamp(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile);

		internal long GetFileTimestamp([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile)
		{
			return _GetFileTimestamp(Self, pchFile);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_GetSyncPlatforms")]
		private static extern RemoteStoragePlatform _GetSyncPlatforms(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile);

		internal RemoteStoragePlatform GetSyncPlatforms([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFile)
		{
			return _GetSyncPlatforms(Self, pchFile);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_GetFileCount")]
		private static extern int _GetFileCount(IntPtr self);

		internal int GetFileCount()
		{
			return _GetFileCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_GetFileNameAndSize")]
		private static extern Utf8StringPointer _GetFileNameAndSize(IntPtr self, int iFile, ref int pnFileSizeInBytes);

		internal string GetFileNameAndSize(int iFile, ref int pnFileSizeInBytes)
		{
			return _GetFileNameAndSize(Self, iFile, ref pnFileSizeInBytes);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_GetQuota")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetQuota(IntPtr self, ref ulong pnTotalBytes, ref ulong puAvailableBytes);

		internal bool GetQuota(ref ulong pnTotalBytes, ref ulong puAvailableBytes)
		{
			return _GetQuota(Self, ref pnTotalBytes, ref puAvailableBytes);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_IsCloudEnabledForAccount")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsCloudEnabledForAccount(IntPtr self);

		internal bool IsCloudEnabledForAccount()
		{
			return _IsCloudEnabledForAccount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_IsCloudEnabledForApp")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsCloudEnabledForApp(IntPtr self);

		internal bool IsCloudEnabledForApp()
		{
			return _IsCloudEnabledForApp(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_SetCloudEnabledForApp")]
		private static extern void _SetCloudEnabledForApp(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bEnabled);

		internal void SetCloudEnabledForApp([MarshalAs(UnmanagedType.U1)] bool bEnabled)
		{
			_SetCloudEnabledForApp(Self, bEnabled);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_UGCDownload")]
		private static extern SteamAPICall_t _UGCDownload(IntPtr self, UGCHandle_t hContent, uint unPriority);

		internal CallResult<RemoteStorageDownloadUGCResult_t> UGCDownload(UGCHandle_t hContent, uint unPriority)
		{
			return new CallResult<RemoteStorageDownloadUGCResult_t>(_UGCDownload(Self, hContent, unPriority), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_GetUGCDownloadProgress")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetUGCDownloadProgress(IntPtr self, UGCHandle_t hContent, ref int pnBytesDownloaded, ref int pnBytesExpected);

		internal bool GetUGCDownloadProgress(UGCHandle_t hContent, ref int pnBytesDownloaded, ref int pnBytesExpected)
		{
			return _GetUGCDownloadProgress(Self, hContent, ref pnBytesDownloaded, ref pnBytesExpected);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_GetUGCDetails")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetUGCDetails(IntPtr self, UGCHandle_t hContent, ref AppId pnAppID, [In][Out] ref char[] ppchName, ref int pnFileSizeInBytes, ref SteamId pSteamIDOwner);

		internal bool GetUGCDetails(UGCHandle_t hContent, ref AppId pnAppID, [In][Out] ref char[] ppchName, ref int pnFileSizeInBytes, ref SteamId pSteamIDOwner)
		{
			return _GetUGCDetails(Self, hContent, ref pnAppID, ref ppchName, ref pnFileSizeInBytes, ref pSteamIDOwner);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_UGCRead")]
		private static extern int _UGCRead(IntPtr self, UGCHandle_t hContent, IntPtr pvData, int cubDataToRead, uint cOffset, UGCReadAction eAction);

		internal int UGCRead(UGCHandle_t hContent, IntPtr pvData, int cubDataToRead, uint cOffset, UGCReadAction eAction)
		{
			return _UGCRead(Self, hContent, pvData, cubDataToRead, cOffset, eAction);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_GetCachedUGCCount")]
		private static extern int _GetCachedUGCCount(IntPtr self);

		internal int GetCachedUGCCount()
		{
			return _GetCachedUGCCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_GetCachedUGCHandle")]
		private static extern UGCHandle_t _GetCachedUGCHandle(IntPtr self, int iCachedContent);

		internal UGCHandle_t GetCachedUGCHandle(int iCachedContent)
		{
			return _GetCachedUGCHandle(Self, iCachedContent);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamRemoteStorage_UGCDownloadToLocation")]
		private static extern SteamAPICall_t _UGCDownloadToLocation(IntPtr self, UGCHandle_t hContent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchLocation, uint unPriority);

		internal CallResult<RemoteStorageDownloadUGCResult_t> UGCDownloadToLocation(UGCHandle_t hContent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchLocation, uint unPriority)
		{
			return new CallResult<RemoteStorageDownloadUGCResult_t>(_UGCDownloadToLocation(Self, hContent, pchLocation, unPriority), base.IsServer);
		}
	}
	internal class ISteamScreenshots : SteamInterface
	{
		internal ISteamScreenshots(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamScreenshots_v003();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamScreenshots_v003();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamScreenshots_WriteScreenshot")]
		private static extern ScreenshotHandle _WriteScreenshot(IntPtr self, IntPtr pubRGB, uint cubRGB, int nWidth, int nHeight);

		internal ScreenshotHandle WriteScreenshot(IntPtr pubRGB, uint cubRGB, int nWidth, int nHeight)
		{
			return _WriteScreenshot(Self, pubRGB, cubRGB, nWidth, nHeight);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamScreenshots_AddScreenshotToLibrary")]
		private static extern ScreenshotHandle _AddScreenshotToLibrary(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFilename, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchThumbnailFilename, int nWidth, int nHeight);

		internal ScreenshotHandle AddScreenshotToLibrary([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFilename, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchThumbnailFilename, int nWidth, int nHeight)
		{
			return _AddScreenshotToLibrary(Self, pchFilename, pchThumbnailFilename, nWidth, nHeight);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamScreenshots_TriggerScreenshot")]
		private static extern void _TriggerScreenshot(IntPtr self);

		internal void TriggerScreenshot()
		{
			_TriggerScreenshot(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamScreenshots_HookScreenshots")]
		private static extern void _HookScreenshots(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bHook);

		internal void HookScreenshots([MarshalAs(UnmanagedType.U1)] bool bHook)
		{
			_HookScreenshots(Self, bHook);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamScreenshots_SetLocation")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetLocation(IntPtr self, ScreenshotHandle hScreenshot, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchLocation);

		internal bool SetLocation(ScreenshotHandle hScreenshot, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchLocation)
		{
			return _SetLocation(Self, hScreenshot, pchLocation);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamScreenshots_TagUser")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _TagUser(IntPtr self, ScreenshotHandle hScreenshot, SteamId steamID);

		internal bool TagUser(ScreenshotHandle hScreenshot, SteamId steamID)
		{
			return _TagUser(Self, hScreenshot, steamID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamScreenshots_TagPublishedFile")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _TagPublishedFile(IntPtr self, ScreenshotHandle hScreenshot, PublishedFileId unPublishedFileID);

		internal bool TagPublishedFile(ScreenshotHandle hScreenshot, PublishedFileId unPublishedFileID)
		{
			return _TagPublishedFile(Self, hScreenshot, unPublishedFileID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamScreenshots_IsScreenshotsHooked")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsScreenshotsHooked(IntPtr self);

		internal bool IsScreenshotsHooked()
		{
			return _IsScreenshotsHooked(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamScreenshots_AddVRScreenshotToLibrary")]
		private static extern ScreenshotHandle _AddVRScreenshotToLibrary(IntPtr self, VRScreenshotType eType, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFilename, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVRFilename);

		internal ScreenshotHandle AddVRScreenshotToLibrary(VRScreenshotType eType, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchFilename, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVRFilename)
		{
			return _AddVRScreenshotToLibrary(Self, eType, pchFilename, pchVRFilename);
		}
	}
	internal class ISteamTV : SteamInterface
	{
		internal ISteamTV(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamTV_v001();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamTV_v001();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamTV_IsBroadcasting")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsBroadcasting(IntPtr self, ref int pnNumViewers);

		internal bool IsBroadcasting(ref int pnNumViewers)
		{
			return _IsBroadcasting(Self, ref pnNumViewers);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamTV_AddBroadcastGameData")]
		private static extern void _AddBroadcastGameData(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue);

		internal void AddBroadcastGameData([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue)
		{
			_AddBroadcastGameData(Self, pchKey, pchValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamTV_RemoveBroadcastGameData")]
		private static extern void _RemoveBroadcastGameData(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey);

		internal void RemoveBroadcastGameData([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey)
		{
			_RemoveBroadcastGameData(Self, pchKey);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamTV_AddTimelineMarker")]
		private static extern void _AddTimelineMarker(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchTemplateName, [MarshalAs(UnmanagedType.U1)] bool bPersistent, byte nColorR, byte nColorG, byte nColorB);

		internal void AddTimelineMarker([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchTemplateName, [MarshalAs(UnmanagedType.U1)] bool bPersistent, byte nColorR, byte nColorG, byte nColorB)
		{
			_AddTimelineMarker(Self, pchTemplateName, bPersistent, nColorR, nColorG, nColorB);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamTV_RemoveTimelineMarker")]
		private static extern void _RemoveTimelineMarker(IntPtr self);

		internal void RemoveTimelineMarker()
		{
			_RemoveTimelineMarker(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamTV_AddRegion")]
		private static extern uint _AddRegion(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchElementName, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchTimelineDataSection, ref SteamTVRegion_t pSteamTVRegion, SteamTVRegionBehavior eSteamTVRegionBehavior);

		internal uint AddRegion([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchElementName, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchTimelineDataSection, ref SteamTVRegion_t pSteamTVRegion, SteamTVRegionBehavior eSteamTVRegionBehavior)
		{
			return _AddRegion(Self, pchElementName, pchTimelineDataSection, ref pSteamTVRegion, eSteamTVRegionBehavior);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamTV_RemoveRegion")]
		private static extern void _RemoveRegion(IntPtr self, uint unRegionHandle);

		internal void RemoveRegion(uint unRegionHandle)
		{
			_RemoveRegion(Self, unRegionHandle);
		}
	}
	internal class ISteamUGC : SteamInterface
	{
		internal ISteamUGC(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamUGC_v014();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamUGC_v014();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamGameServerUGC_v014();

		public override IntPtr GetServerInterfacePointer()
		{
			return SteamAPI_SteamGameServerUGC_v014();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_CreateQueryUserUGCRequest")]
		private static extern UGCQueryHandle_t _CreateQueryUserUGCRequest(IntPtr self, AccountID_t unAccountID, UserUGCList eListType, UgcType eMatchingUGCType, UserUGCListSortOrder eSortOrder, AppId nCreatorAppID, AppId nConsumerAppID, uint unPage);

		internal UGCQueryHandle_t CreateQueryUserUGCRequest(AccountID_t unAccountID, UserUGCList eListType, UgcType eMatchingUGCType, UserUGCListSortOrder eSortOrder, AppId nCreatorAppID, AppId nConsumerAppID, uint unPage)
		{
			return _CreateQueryUserUGCRequest(Self, unAccountID, eListType, eMatchingUGCType, eSortOrder, nCreatorAppID, nConsumerAppID, unPage);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_CreateQueryAllUGCRequestPage")]
		private static extern UGCQueryHandle_t _CreateQueryAllUGCRequest(IntPtr self, UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, uint unPage);

		internal UGCQueryHandle_t CreateQueryAllUGCRequest(UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, uint unPage)
		{
			return _CreateQueryAllUGCRequest(Self, eQueryType, eMatchingeMatchingUGCTypeFileType, nCreatorAppID, nConsumerAppID, unPage);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_CreateQueryAllUGCRequestCursor")]
		private static extern UGCQueryHandle_t _CreateQueryAllUGCRequest(IntPtr self, UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchCursor);

		internal UGCQueryHandle_t CreateQueryAllUGCRequest(UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchCursor)
		{
			return _CreateQueryAllUGCRequest(Self, eQueryType, eMatchingeMatchingUGCTypeFileType, nCreatorAppID, nConsumerAppID, pchCursor);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_CreateQueryUGCDetailsRequest")]
		private static extern UGCQueryHandle_t _CreateQueryUGCDetailsRequest(IntPtr self, [In][Out] PublishedFileId[] pvecPublishedFileID, uint unNumPublishedFileIDs);

		internal UGCQueryHandle_t CreateQueryUGCDetailsRequest([In][Out] PublishedFileId[] pvecPublishedFileID, uint unNumPublishedFileIDs)
		{
			return _CreateQueryUGCDetailsRequest(Self, pvecPublishedFileID, unNumPublishedFileIDs);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SendQueryUGCRequest")]
		private static extern SteamAPICall_t _SendQueryUGCRequest(IntPtr self, UGCQueryHandle_t handle);

		internal CallResult<SteamUGCQueryCompleted_t> SendQueryUGCRequest(UGCQueryHandle_t handle)
		{
			return new CallResult<SteamUGCQueryCompleted_t>(_SendQueryUGCRequest(Self, handle), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetQueryUGCResult")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetQueryUGCResult(IntPtr self, UGCQueryHandle_t handle, uint index, ref SteamUGCDetails_t pDetails);

		internal bool GetQueryUGCResult(UGCQueryHandle_t handle, uint index, ref SteamUGCDetails_t pDetails)
		{
			return _GetQueryUGCResult(Self, handle, index, ref pDetails);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetQueryUGCPreviewURL")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetQueryUGCPreviewURL(IntPtr self, UGCQueryHandle_t handle, uint index, IntPtr pchURL, uint cchURLSize);

		internal bool GetQueryUGCPreviewURL(UGCQueryHandle_t handle, uint index, out string pchURL)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _GetQueryUGCPreviewURL(Self, handle, index, intPtr, 32768u);
			pchURL = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetQueryUGCMetadata")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetQueryUGCMetadata(IntPtr self, UGCQueryHandle_t handle, uint index, IntPtr pchMetadata, uint cchMetadatasize);

		internal bool GetQueryUGCMetadata(UGCQueryHandle_t handle, uint index, out string pchMetadata)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _GetQueryUGCMetadata(Self, handle, index, intPtr, 32768u);
			pchMetadata = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetQueryUGCChildren")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetQueryUGCChildren(IntPtr self, UGCQueryHandle_t handle, uint index, [In][Out] PublishedFileId[] pvecPublishedFileID, uint cMaxEntries);

		internal bool GetQueryUGCChildren(UGCQueryHandle_t handle, uint index, [In][Out] PublishedFileId[] pvecPublishedFileID, uint cMaxEntries)
		{
			return _GetQueryUGCChildren(Self, handle, index, pvecPublishedFileID, cMaxEntries);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetQueryUGCStatistic")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetQueryUGCStatistic(IntPtr self, UGCQueryHandle_t handle, uint index, ItemStatistic eStatType, ref ulong pStatValue);

		internal bool GetQueryUGCStatistic(UGCQueryHandle_t handle, uint index, ItemStatistic eStatType, ref ulong pStatValue)
		{
			return _GetQueryUGCStatistic(Self, handle, index, eStatType, ref pStatValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetQueryUGCNumAdditionalPreviews")]
		private static extern uint _GetQueryUGCNumAdditionalPreviews(IntPtr self, UGCQueryHandle_t handle, uint index);

		internal uint GetQueryUGCNumAdditionalPreviews(UGCQueryHandle_t handle, uint index)
		{
			return _GetQueryUGCNumAdditionalPreviews(Self, handle, index);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetQueryUGCAdditionalPreview")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetQueryUGCAdditionalPreview(IntPtr self, UGCQueryHandle_t handle, uint index, uint previewIndex, IntPtr pchURLOrVideoID, uint cchURLSize, IntPtr pchOriginalFileName, uint cchOriginalFileNameSize, ref ItemPreviewType pPreviewType);

		internal bool GetQueryUGCAdditionalPreview(UGCQueryHandle_t handle, uint index, uint previewIndex, out string pchURLOrVideoID, out string pchOriginalFileName, ref ItemPreviewType pPreviewType)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			IntPtr intPtr2 = Helpers.TakeMemory();
			bool result = _GetQueryUGCAdditionalPreview(Self, handle, index, previewIndex, intPtr, 32768u, intPtr2, 32768u, ref pPreviewType);
			pchURLOrVideoID = Helpers.MemoryToString(intPtr);
			pchOriginalFileName = Helpers.MemoryToString(intPtr2);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetQueryUGCNumKeyValueTags")]
		private static extern uint _GetQueryUGCNumKeyValueTags(IntPtr self, UGCQueryHandle_t handle, uint index);

		internal uint GetQueryUGCNumKeyValueTags(UGCQueryHandle_t handle, uint index)
		{
			return _GetQueryUGCNumKeyValueTags(Self, handle, index);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetQueryUGCKeyValueTag(IntPtr self, UGCQueryHandle_t handle, uint index, uint keyValueTagIndex, IntPtr pchKey, uint cchKeySize, IntPtr pchValue, uint cchValueSize);

		internal bool GetQueryUGCKeyValueTag(UGCQueryHandle_t handle, uint index, uint keyValueTagIndex, out string pchKey, out string pchValue)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			IntPtr intPtr2 = Helpers.TakeMemory();
			bool result = _GetQueryUGCKeyValueTag(Self, handle, index, keyValueTagIndex, intPtr, 32768u, intPtr2, 32768u);
			pchKey = Helpers.MemoryToString(intPtr);
			pchValue = Helpers.MemoryToString(intPtr2);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetQueryFirstUGCKeyValueTag")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetQueryUGCKeyValueTag(IntPtr self, UGCQueryHandle_t handle, uint index, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, IntPtr pchValue, uint cchValueSize);

		internal bool GetQueryUGCKeyValueTag(UGCQueryHandle_t handle, uint index, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, out string pchValue)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _GetQueryUGCKeyValueTag(Self, handle, index, pchKey, intPtr, 32768u);
			pchValue = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_ReleaseQueryUGCRequest")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ReleaseQueryUGCRequest(IntPtr self, UGCQueryHandle_t handle);

		internal bool ReleaseQueryUGCRequest(UGCQueryHandle_t handle)
		{
			return _ReleaseQueryUGCRequest(Self, handle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_AddRequiredTag")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _AddRequiredTag(IntPtr self, UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pTagName);

		internal bool AddRequiredTag(UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pTagName)
		{
			return _AddRequiredTag(Self, handle, pTagName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_AddRequiredTagGroup")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _AddRequiredTagGroup(IntPtr self, UGCQueryHandle_t handle, ref SteamParamStringArray_t pTagGroups);

		internal bool AddRequiredTagGroup(UGCQueryHandle_t handle, ref SteamParamStringArray_t pTagGroups)
		{
			return _AddRequiredTagGroup(Self, handle, ref pTagGroups);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_AddExcludedTag")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _AddExcludedTag(IntPtr self, UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pTagName);

		internal bool AddExcludedTag(UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pTagName)
		{
			return _AddExcludedTag(Self, handle, pTagName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetReturnOnlyIDs")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetReturnOnlyIDs(IntPtr self, UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bReturnOnlyIDs);

		internal bool SetReturnOnlyIDs(UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bReturnOnlyIDs)
		{
			return _SetReturnOnlyIDs(Self, handle, bReturnOnlyIDs);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetReturnKeyValueTags")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetReturnKeyValueTags(IntPtr self, UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bReturnKeyValueTags);

		internal bool SetReturnKeyValueTags(UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bReturnKeyValueTags)
		{
			return _SetReturnKeyValueTags(Self, handle, bReturnKeyValueTags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetReturnLongDescription")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetReturnLongDescription(IntPtr self, UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bReturnLongDescription);

		internal bool SetReturnLongDescription(UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bReturnLongDescription)
		{
			return _SetReturnLongDescription(Self, handle, bReturnLongDescription);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetReturnMetadata")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetReturnMetadata(IntPtr self, UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bReturnMetadata);

		internal bool SetReturnMetadata(UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bReturnMetadata)
		{
			return _SetReturnMetadata(Self, handle, bReturnMetadata);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetReturnChildren")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetReturnChildren(IntPtr self, UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bReturnChildren);

		internal bool SetReturnChildren(UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bReturnChildren)
		{
			return _SetReturnChildren(Self, handle, bReturnChildren);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetReturnAdditionalPreviews")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetReturnAdditionalPreviews(IntPtr self, UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bReturnAdditionalPreviews);

		internal bool SetReturnAdditionalPreviews(UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bReturnAdditionalPreviews)
		{
			return _SetReturnAdditionalPreviews(Self, handle, bReturnAdditionalPreviews);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetReturnTotalOnly")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetReturnTotalOnly(IntPtr self, UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bReturnTotalOnly);

		internal bool SetReturnTotalOnly(UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bReturnTotalOnly)
		{
			return _SetReturnTotalOnly(Self, handle, bReturnTotalOnly);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetReturnPlaytimeStats")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetReturnPlaytimeStats(IntPtr self, UGCQueryHandle_t handle, uint unDays);

		internal bool SetReturnPlaytimeStats(UGCQueryHandle_t handle, uint unDays)
		{
			return _SetReturnPlaytimeStats(Self, handle, unDays);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetLanguage")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetLanguage(IntPtr self, UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchLanguage);

		internal bool SetLanguage(UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchLanguage)
		{
			return _SetLanguage(Self, handle, pchLanguage);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetAllowCachedResponse")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetAllowCachedResponse(IntPtr self, UGCQueryHandle_t handle, uint unMaxAgeSeconds);

		internal bool SetAllowCachedResponse(UGCQueryHandle_t handle, uint unMaxAgeSeconds)
		{
			return _SetAllowCachedResponse(Self, handle, unMaxAgeSeconds);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetCloudFileNameFilter")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetCloudFileNameFilter(IntPtr self, UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pMatchCloudFileName);

		internal bool SetCloudFileNameFilter(UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pMatchCloudFileName)
		{
			return _SetCloudFileNameFilter(Self, handle, pMatchCloudFileName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetMatchAnyTag")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetMatchAnyTag(IntPtr self, UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bMatchAnyTag);

		internal bool SetMatchAnyTag(UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bMatchAnyTag)
		{
			return _SetMatchAnyTag(Self, handle, bMatchAnyTag);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetSearchText")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetSearchText(IntPtr self, UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pSearchText);

		internal bool SetSearchText(UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pSearchText)
		{
			return _SetSearchText(Self, handle, pSearchText);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetRankedByTrendDays")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetRankedByTrendDays(IntPtr self, UGCQueryHandle_t handle, uint unDays);

		internal bool SetRankedByTrendDays(UGCQueryHandle_t handle, uint unDays)
		{
			return _SetRankedByTrendDays(Self, handle, unDays);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_AddRequiredKeyValueTag")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _AddRequiredKeyValueTag(IntPtr self, UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pValue);

		internal bool AddRequiredKeyValueTag(UGCQueryHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pValue)
		{
			return _AddRequiredKeyValueTag(Self, handle, pKey, pValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_RequestUGCDetails")]
		private static extern SteamAPICall_t _RequestUGCDetails(IntPtr self, PublishedFileId nPublishedFileID, uint unMaxAgeSeconds);

		internal CallResult<SteamUGCRequestUGCDetailsResult_t> RequestUGCDetails(PublishedFileId nPublishedFileID, uint unMaxAgeSeconds)
		{
			return new CallResult<SteamUGCRequestUGCDetailsResult_t>(_RequestUGCDetails(Self, nPublishedFileID, unMaxAgeSeconds), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_CreateItem")]
		private static extern SteamAPICall_t _CreateItem(IntPtr self, AppId nConsumerAppId, WorkshopFileType eFileType);

		internal CallResult<CreateItemResult_t> CreateItem(AppId nConsumerAppId, WorkshopFileType eFileType)
		{
			return new CallResult<CreateItemResult_t>(_CreateItem(Self, nConsumerAppId, eFileType), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_StartItemUpdate")]
		private static extern UGCUpdateHandle_t _StartItemUpdate(IntPtr self, AppId nConsumerAppId, PublishedFileId nPublishedFileID);

		internal UGCUpdateHandle_t StartItemUpdate(AppId nConsumerAppId, PublishedFileId nPublishedFileID)
		{
			return _StartItemUpdate(Self, nConsumerAppId, nPublishedFileID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetItemTitle")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetItemTitle(IntPtr self, UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchTitle);

		internal bool SetItemTitle(UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchTitle)
		{
			return _SetItemTitle(Self, handle, pchTitle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetItemDescription")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetItemDescription(IntPtr self, UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchDescription);

		internal bool SetItemDescription(UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchDescription)
		{
			return _SetItemDescription(Self, handle, pchDescription);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetItemUpdateLanguage")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetItemUpdateLanguage(IntPtr self, UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchLanguage);

		internal bool SetItemUpdateLanguage(UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchLanguage)
		{
			return _SetItemUpdateLanguage(Self, handle, pchLanguage);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetItemMetadata")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetItemMetadata(IntPtr self, UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchMetaData);

		internal bool SetItemMetadata(UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchMetaData)
		{
			return _SetItemMetadata(Self, handle, pchMetaData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetItemVisibility")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetItemVisibility(IntPtr self, UGCUpdateHandle_t handle, RemoteStoragePublishedFileVisibility eVisibility);

		internal bool SetItemVisibility(UGCUpdateHandle_t handle, RemoteStoragePublishedFileVisibility eVisibility)
		{
			return _SetItemVisibility(Self, handle, eVisibility);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetItemTags")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetItemTags(IntPtr self, UGCUpdateHandle_t updateHandle, ref SteamParamStringArray_t pTags);

		internal bool SetItemTags(UGCUpdateHandle_t updateHandle, ref SteamParamStringArray_t pTags)
		{
			return _SetItemTags(Self, updateHandle, ref pTags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetItemContent")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetItemContent(IntPtr self, UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszContentFolder);

		internal bool SetItemContent(UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszContentFolder)
		{
			return _SetItemContent(Self, handle, pszContentFolder);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetItemPreview")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetItemPreview(IntPtr self, UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszPreviewFile);

		internal bool SetItemPreview(UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszPreviewFile)
		{
			return _SetItemPreview(Self, handle, pszPreviewFile);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetAllowLegacyUpload")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetAllowLegacyUpload(IntPtr self, UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bAllowLegacyUpload);

		internal bool SetAllowLegacyUpload(UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.U1)] bool bAllowLegacyUpload)
		{
			return _SetAllowLegacyUpload(Self, handle, bAllowLegacyUpload);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_RemoveAllItemKeyValueTags")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _RemoveAllItemKeyValueTags(IntPtr self, UGCUpdateHandle_t handle);

		internal bool RemoveAllItemKeyValueTags(UGCUpdateHandle_t handle)
		{
			return _RemoveAllItemKeyValueTags(Self, handle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_RemoveItemKeyValueTags")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _RemoveItemKeyValueTags(IntPtr self, UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey);

		internal bool RemoveItemKeyValueTags(UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey)
		{
			return _RemoveItemKeyValueTags(Self, handle, pchKey);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_AddItemKeyValueTag")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _AddItemKeyValueTag(IntPtr self, UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue);

		internal bool AddItemKeyValueTag(UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchValue)
		{
			return _AddItemKeyValueTag(Self, handle, pchKey, pchValue);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_AddItemPreviewFile")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _AddItemPreviewFile(IntPtr self, UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszPreviewFile, ItemPreviewType type);

		internal bool AddItemPreviewFile(UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszPreviewFile, ItemPreviewType type)
		{
			return _AddItemPreviewFile(Self, handle, pszPreviewFile, type);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_AddItemPreviewVideo")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _AddItemPreviewVideo(IntPtr self, UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszVideoID);

		internal bool AddItemPreviewVideo(UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszVideoID)
		{
			return _AddItemPreviewVideo(Self, handle, pszVideoID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_UpdateItemPreviewFile")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _UpdateItemPreviewFile(IntPtr self, UGCUpdateHandle_t handle, uint index, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszPreviewFile);

		internal bool UpdateItemPreviewFile(UGCUpdateHandle_t handle, uint index, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszPreviewFile)
		{
			return _UpdateItemPreviewFile(Self, handle, index, pszPreviewFile);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_UpdateItemPreviewVideo")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _UpdateItemPreviewVideo(IntPtr self, UGCUpdateHandle_t handle, uint index, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszVideoID);

		internal bool UpdateItemPreviewVideo(UGCUpdateHandle_t handle, uint index, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszVideoID)
		{
			return _UpdateItemPreviewVideo(Self, handle, index, pszVideoID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_RemoveItemPreview")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _RemoveItemPreview(IntPtr self, UGCUpdateHandle_t handle, uint index);

		internal bool RemoveItemPreview(UGCUpdateHandle_t handle, uint index)
		{
			return _RemoveItemPreview(Self, handle, index);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SubmitItemUpdate")]
		private static extern SteamAPICall_t _SubmitItemUpdate(IntPtr self, UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchChangeNote);

		internal CallResult<SubmitItemUpdateResult_t> SubmitItemUpdate(UGCUpdateHandle_t handle, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchChangeNote)
		{
			return new CallResult<SubmitItemUpdateResult_t>(_SubmitItemUpdate(Self, handle, pchChangeNote), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetItemUpdateProgress")]
		private static extern ItemUpdateStatus _GetItemUpdateProgress(IntPtr self, UGCUpdateHandle_t handle, ref ulong punBytesProcessed, ref ulong punBytesTotal);

		internal ItemUpdateStatus GetItemUpdateProgress(UGCUpdateHandle_t handle, ref ulong punBytesProcessed, ref ulong punBytesTotal)
		{
			return _GetItemUpdateProgress(Self, handle, ref punBytesProcessed, ref punBytesTotal);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SetUserItemVote")]
		private static extern SteamAPICall_t _SetUserItemVote(IntPtr self, PublishedFileId nPublishedFileID, [MarshalAs(UnmanagedType.U1)] bool bVoteUp);

		internal CallResult<SetUserItemVoteResult_t> SetUserItemVote(PublishedFileId nPublishedFileID, [MarshalAs(UnmanagedType.U1)] bool bVoteUp)
		{
			return new CallResult<SetUserItemVoteResult_t>(_SetUserItemVote(Self, nPublishedFileID, bVoteUp), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetUserItemVote")]
		private static extern SteamAPICall_t _GetUserItemVote(IntPtr self, PublishedFileId nPublishedFileID);

		internal CallResult<GetUserItemVoteResult_t> GetUserItemVote(PublishedFileId nPublishedFileID)
		{
			return new CallResult<GetUserItemVoteResult_t>(_GetUserItemVote(Self, nPublishedFileID), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_AddItemToFavorites")]
		private static extern SteamAPICall_t _AddItemToFavorites(IntPtr self, AppId nAppId, PublishedFileId nPublishedFileID);

		internal CallResult<UserFavoriteItemsListChanged_t> AddItemToFavorites(AppId nAppId, PublishedFileId nPublishedFileID)
		{
			return new CallResult<UserFavoriteItemsListChanged_t>(_AddItemToFavorites(Self, nAppId, nPublishedFileID), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_RemoveItemFromFavorites")]
		private static extern SteamAPICall_t _RemoveItemFromFavorites(IntPtr self, AppId nAppId, PublishedFileId nPublishedFileID);

		internal CallResult<UserFavoriteItemsListChanged_t> RemoveItemFromFavorites(AppId nAppId, PublishedFileId nPublishedFileID)
		{
			return new CallResult<UserFavoriteItemsListChanged_t>(_RemoveItemFromFavorites(Self, nAppId, nPublishedFileID), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SubscribeItem")]
		private static extern SteamAPICall_t _SubscribeItem(IntPtr self, PublishedFileId nPublishedFileID);

		internal CallResult<RemoteStorageSubscribePublishedFileResult_t> SubscribeItem(PublishedFileId nPublishedFileID)
		{
			return new CallResult<RemoteStorageSubscribePublishedFileResult_t>(_SubscribeItem(Self, nPublishedFileID), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_UnsubscribeItem")]
		private static extern SteamAPICall_t _UnsubscribeItem(IntPtr self, PublishedFileId nPublishedFileID);

		internal CallResult<RemoteStorageUnsubscribePublishedFileResult_t> UnsubscribeItem(PublishedFileId nPublishedFileID)
		{
			return new CallResult<RemoteStorageUnsubscribePublishedFileResult_t>(_UnsubscribeItem(Self, nPublishedFileID), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetNumSubscribedItems")]
		private static extern uint _GetNumSubscribedItems(IntPtr self);

		internal uint GetNumSubscribedItems()
		{
			return _GetNumSubscribedItems(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetSubscribedItems")]
		private static extern uint _GetSubscribedItems(IntPtr self, [In][Out] PublishedFileId[] pvecPublishedFileID, uint cMaxEntries);

		internal uint GetSubscribedItems([In][Out] PublishedFileId[] pvecPublishedFileID, uint cMaxEntries)
		{
			return _GetSubscribedItems(Self, pvecPublishedFileID, cMaxEntries);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetItemState")]
		private static extern uint _GetItemState(IntPtr self, PublishedFileId nPublishedFileID);

		internal uint GetItemState(PublishedFileId nPublishedFileID)
		{
			return _GetItemState(Self, nPublishedFileID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetItemInstallInfo")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetItemInstallInfo(IntPtr self, PublishedFileId nPublishedFileID, ref ulong punSizeOnDisk, IntPtr pchFolder, uint cchFolderSize, ref uint punTimeStamp);

		internal bool GetItemInstallInfo(PublishedFileId nPublishedFileID, ref ulong punSizeOnDisk, out string pchFolder, ref uint punTimeStamp)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _GetItemInstallInfo(Self, nPublishedFileID, ref punSizeOnDisk, intPtr, 32768u, ref punTimeStamp);
			pchFolder = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetItemDownloadInfo")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetItemDownloadInfo(IntPtr self, PublishedFileId nPublishedFileID, ref ulong punBytesDownloaded, ref ulong punBytesTotal);

		internal bool GetItemDownloadInfo(PublishedFileId nPublishedFileID, ref ulong punBytesDownloaded, ref ulong punBytesTotal)
		{
			return _GetItemDownloadInfo(Self, nPublishedFileID, ref punBytesDownloaded, ref punBytesTotal);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_DownloadItem")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _DownloadItem(IntPtr self, PublishedFileId nPublishedFileID, [MarshalAs(UnmanagedType.U1)] bool bHighPriority);

		internal bool DownloadItem(PublishedFileId nPublishedFileID, [MarshalAs(UnmanagedType.U1)] bool bHighPriority)
		{
			return _DownloadItem(Self, nPublishedFileID, bHighPriority);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_BInitWorkshopForGameServer")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BInitWorkshopForGameServer(IntPtr self, DepotId_t unWorkshopDepotID, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszFolder);

		internal bool BInitWorkshopForGameServer(DepotId_t unWorkshopDepotID, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszFolder)
		{
			return _BInitWorkshopForGameServer(Self, unWorkshopDepotID, pszFolder);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_SuspendDownloads")]
		private static extern void _SuspendDownloads(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bSuspend);

		internal void SuspendDownloads([MarshalAs(UnmanagedType.U1)] bool bSuspend)
		{
			_SuspendDownloads(Self, bSuspend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_StartPlaytimeTracking")]
		private static extern SteamAPICall_t _StartPlaytimeTracking(IntPtr self, [In][Out] PublishedFileId[] pvecPublishedFileID, uint unNumPublishedFileIDs);

		internal CallResult<StartPlaytimeTrackingResult_t> StartPlaytimeTracking([In][Out] PublishedFileId[] pvecPublishedFileID, uint unNumPublishedFileIDs)
		{
			return new CallResult<StartPlaytimeTrackingResult_t>(_StartPlaytimeTracking(Self, pvecPublishedFileID, unNumPublishedFileIDs), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_StopPlaytimeTracking")]
		private static extern SteamAPICall_t _StopPlaytimeTracking(IntPtr self, [In][Out] PublishedFileId[] pvecPublishedFileID, uint unNumPublishedFileIDs);

		internal CallResult<StopPlaytimeTrackingResult_t> StopPlaytimeTracking([In][Out] PublishedFileId[] pvecPublishedFileID, uint unNumPublishedFileIDs)
		{
			return new CallResult<StopPlaytimeTrackingResult_t>(_StopPlaytimeTracking(Self, pvecPublishedFileID, unNumPublishedFileIDs), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_StopPlaytimeTrackingForAllItems")]
		private static extern SteamAPICall_t _StopPlaytimeTrackingForAllItems(IntPtr self);

		internal CallResult<StopPlaytimeTrackingResult_t> StopPlaytimeTrackingForAllItems()
		{
			return new CallResult<StopPlaytimeTrackingResult_t>(_StopPlaytimeTrackingForAllItems(Self), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_AddDependency")]
		private static extern SteamAPICall_t _AddDependency(IntPtr self, PublishedFileId nParentPublishedFileID, PublishedFileId nChildPublishedFileID);

		internal CallResult<AddUGCDependencyResult_t> AddDependency(PublishedFileId nParentPublishedFileID, PublishedFileId nChildPublishedFileID)
		{
			return new CallResult<AddUGCDependencyResult_t>(_AddDependency(Self, nParentPublishedFileID, nChildPublishedFileID), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_RemoveDependency")]
		private static extern SteamAPICall_t _RemoveDependency(IntPtr self, PublishedFileId nParentPublishedFileID, PublishedFileId nChildPublishedFileID);

		internal CallResult<RemoveUGCDependencyResult_t> RemoveDependency(PublishedFileId nParentPublishedFileID, PublishedFileId nChildPublishedFileID)
		{
			return new CallResult<RemoveUGCDependencyResult_t>(_RemoveDependency(Self, nParentPublishedFileID, nChildPublishedFileID), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_AddAppDependency")]
		private static extern SteamAPICall_t _AddAppDependency(IntPtr self, PublishedFileId nPublishedFileID, AppId nAppID);

		internal CallResult<AddAppDependencyResult_t> AddAppDependency(PublishedFileId nPublishedFileID, AppId nAppID)
		{
			return new CallResult<AddAppDependencyResult_t>(_AddAppDependency(Self, nPublishedFileID, nAppID), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_RemoveAppDependency")]
		private static extern SteamAPICall_t _RemoveAppDependency(IntPtr self, PublishedFileId nPublishedFileID, AppId nAppID);

		internal CallResult<RemoveAppDependencyResult_t> RemoveAppDependency(PublishedFileId nPublishedFileID, AppId nAppID)
		{
			return new CallResult<RemoveAppDependencyResult_t>(_RemoveAppDependency(Self, nPublishedFileID, nAppID), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_GetAppDependencies")]
		private static extern SteamAPICall_t _GetAppDependencies(IntPtr self, PublishedFileId nPublishedFileID);

		internal CallResult<GetAppDependenciesResult_t> GetAppDependencies(PublishedFileId nPublishedFileID)
		{
			return new CallResult<GetAppDependenciesResult_t>(_GetAppDependencies(Self, nPublishedFileID), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUGC_DeleteItem")]
		private static extern SteamAPICall_t _DeleteItem(IntPtr self, PublishedFileId nPublishedFileID);

		internal CallResult<DeleteItemResult_t> DeleteItem(PublishedFileId nPublishedFileID)
		{
			return new CallResult<DeleteItemResult_t>(_DeleteItem(Self, nPublishedFileID), base.IsServer);
		}
	}
	internal class ISteamUser : SteamInterface
	{
		internal ISteamUser(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamUser_v020();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamUser_v020();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_GetHSteamUser")]
		private static extern HSteamUser _GetHSteamUser(IntPtr self);

		internal HSteamUser GetHSteamUser()
		{
			return _GetHSteamUser(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_BLoggedOn")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BLoggedOn(IntPtr self);

		internal bool BLoggedOn()
		{
			return _BLoggedOn(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_GetSteamID")]
		private static extern SteamId _GetSteamID(IntPtr self);

		internal SteamId GetSteamID()
		{
			return _GetSteamID(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_InitiateGameConnection")]
		private static extern int _InitiateGameConnection(IntPtr self, IntPtr pAuthBlob, int cbMaxAuthBlob, SteamId steamIDGameServer, uint unIPServer, ushort usPortServer, [MarshalAs(UnmanagedType.U1)] bool bSecure);

		internal int InitiateGameConnection(IntPtr pAuthBlob, int cbMaxAuthBlob, SteamId steamIDGameServer, uint unIPServer, ushort usPortServer, [MarshalAs(UnmanagedType.U1)] bool bSecure)
		{
			return _InitiateGameConnection(Self, pAuthBlob, cbMaxAuthBlob, steamIDGameServer, unIPServer, usPortServer, bSecure);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_TerminateGameConnection")]
		private static extern void _TerminateGameConnection(IntPtr self, uint unIPServer, ushort usPortServer);

		internal void TerminateGameConnection(uint unIPServer, ushort usPortServer)
		{
			_TerminateGameConnection(Self, unIPServer, usPortServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_TrackAppUsageEvent")]
		private static extern void _TrackAppUsageEvent(IntPtr self, GameId gameID, int eAppUsageEvent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchExtraInfo);

		internal void TrackAppUsageEvent(GameId gameID, int eAppUsageEvent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchExtraInfo)
		{
			_TrackAppUsageEvent(Self, gameID, eAppUsageEvent, pchExtraInfo);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_GetUserDataFolder")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetUserDataFolder(IntPtr self, IntPtr pchBuffer, int cubBuffer);

		internal bool GetUserDataFolder(out string pchBuffer)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _GetUserDataFolder(Self, intPtr, 32768);
			pchBuffer = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_StartVoiceRecording")]
		private static extern void _StartVoiceRecording(IntPtr self);

		internal void StartVoiceRecording()
		{
			_StartVoiceRecording(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_StopVoiceRecording")]
		private static extern void _StopVoiceRecording(IntPtr self);

		internal void StopVoiceRecording()
		{
			_StopVoiceRecording(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_GetAvailableVoice")]
		private static extern VoiceResult _GetAvailableVoice(IntPtr self, ref uint pcbCompressed, ref uint pcbUncompressed_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated);

		internal VoiceResult GetAvailableVoice(ref uint pcbCompressed, ref uint pcbUncompressed_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated)
		{
			return _GetAvailableVoice(Self, ref pcbCompressed, ref pcbUncompressed_Deprecated, nUncompressedVoiceDesiredSampleRate_Deprecated);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_GetVoice")]
		private static extern VoiceResult _GetVoice(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bWantCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, [MarshalAs(UnmanagedType.U1)] bool bWantUncompressed_Deprecated, IntPtr pUncompressedDestBuffer_Deprecated, uint cbUncompressedDestBufferSize_Deprecated, ref uint nUncompressBytesWritten_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated);

		internal VoiceResult GetVoice([MarshalAs(UnmanagedType.U1)] bool bWantCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, [MarshalAs(UnmanagedType.U1)] bool bWantUncompressed_Deprecated, IntPtr pUncompressedDestBuffer_Deprecated, uint cbUncompressedDestBufferSize_Deprecated, ref uint nUncompressBytesWritten_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated)
		{
			return _GetVoice(Self, bWantCompressed, pDestBuffer, cbDestBufferSize, ref nBytesWritten, bWantUncompressed_Deprecated, pUncompressedDestBuffer_Deprecated, cbUncompressedDestBufferSize_Deprecated, ref nUncompressBytesWritten_Deprecated, nUncompressedVoiceDesiredSampleRate_Deprecated);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_DecompressVoice")]
		private static extern VoiceResult _DecompressVoice(IntPtr self, IntPtr pCompressed, uint cbCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, uint nDesiredSampleRate);

		internal VoiceResult DecompressVoice(IntPtr pCompressed, uint cbCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, uint nDesiredSampleRate)
		{
			return _DecompressVoice(Self, pCompressed, cbCompressed, pDestBuffer, cbDestBufferSize, ref nBytesWritten, nDesiredSampleRate);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_GetVoiceOptimalSampleRate")]
		private static extern uint _GetVoiceOptimalSampleRate(IntPtr self);

		internal uint GetVoiceOptimalSampleRate()
		{
			return _GetVoiceOptimalSampleRate(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_GetAuthSessionTicket")]
		private static extern HAuthTicket _GetAuthSessionTicket(IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket);

		internal HAuthTicket GetAuthSessionTicket(IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket)
		{
			return _GetAuthSessionTicket(Self, pTicket, cbMaxTicket, ref pcbTicket);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_BeginAuthSession")]
		private static extern BeginAuthResult _BeginAuthSession(IntPtr self, IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID);

		internal BeginAuthResult BeginAuthSession(IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID)
		{
			return _BeginAuthSession(Self, pAuthTicket, cbAuthTicket, steamID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_EndAuthSession")]
		private static extern void _EndAuthSession(IntPtr self, SteamId steamID);

		internal void EndAuthSession(SteamId steamID)
		{
			_EndAuthSession(Self, steamID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_CancelAuthTicket")]
		private static extern void _CancelAuthTicket(IntPtr self, HAuthTicket hAuthTicket);

		internal void CancelAuthTicket(HAuthTicket hAuthTicket)
		{
			_CancelAuthTicket(Self, hAuthTicket);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_UserHasLicenseForApp")]
		private static extern UserHasLicenseForAppResult _UserHasLicenseForApp(IntPtr self, SteamId steamID, AppId appID);

		internal UserHasLicenseForAppResult UserHasLicenseForApp(SteamId steamID, AppId appID)
		{
			return _UserHasLicenseForApp(Self, steamID, appID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_BIsBehindNAT")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsBehindNAT(IntPtr self);

		internal bool BIsBehindNAT()
		{
			return _BIsBehindNAT(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_AdvertiseGame")]
		private static extern void _AdvertiseGame(IntPtr self, SteamId steamIDGameServer, uint unIPServer, ushort usPortServer);

		internal void AdvertiseGame(SteamId steamIDGameServer, uint unIPServer, ushort usPortServer)
		{
			_AdvertiseGame(Self, steamIDGameServer, unIPServer, usPortServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_RequestEncryptedAppTicket")]
		private static extern SteamAPICall_t _RequestEncryptedAppTicket(IntPtr self, IntPtr pDataToInclude, int cbDataToInclude);

		internal CallResult<EncryptedAppTicketResponse_t> RequestEncryptedAppTicket(IntPtr pDataToInclude, int cbDataToInclude)
		{
			return new CallResult<EncryptedAppTicketResponse_t>(_RequestEncryptedAppTicket(Self, pDataToInclude, cbDataToInclude), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_GetEncryptedAppTicket")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetEncryptedAppTicket(IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket);

		internal bool GetEncryptedAppTicket(IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket)
		{
			return _GetEncryptedAppTicket(Self, pTicket, cbMaxTicket, ref pcbTicket);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_GetGameBadgeLevel")]
		private static extern int _GetGameBadgeLevel(IntPtr self, int nSeries, [MarshalAs(UnmanagedType.U1)] bool bFoil);

		internal int GetGameBadgeLevel(int nSeries, [MarshalAs(UnmanagedType.U1)] bool bFoil)
		{
			return _GetGameBadgeLevel(Self, nSeries, bFoil);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_GetPlayerSteamLevel")]
		private static extern int _GetPlayerSteamLevel(IntPtr self);

		internal int GetPlayerSteamLevel()
		{
			return _GetPlayerSteamLevel(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_RequestStoreAuthURL")]
		private static extern SteamAPICall_t _RequestStoreAuthURL(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchRedirectURL);

		internal CallResult<StoreAuthURLResponse_t> RequestStoreAuthURL([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchRedirectURL)
		{
			return new CallResult<StoreAuthURLResponse_t>(_RequestStoreAuthURL(Self, pchRedirectURL), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_BIsPhoneVerified")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsPhoneVerified(IntPtr self);

		internal bool BIsPhoneVerified()
		{
			return _BIsPhoneVerified(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_BIsTwoFactorEnabled")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsTwoFactorEnabled(IntPtr self);

		internal bool BIsTwoFactorEnabled()
		{
			return _BIsTwoFactorEnabled(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_BIsPhoneIdentifying")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsPhoneIdentifying(IntPtr self);

		internal bool BIsPhoneIdentifying()
		{
			return _BIsPhoneIdentifying(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_BIsPhoneRequiringVerification")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsPhoneRequiringVerification(IntPtr self);

		internal bool BIsPhoneRequiringVerification()
		{
			return _BIsPhoneRequiringVerification(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_GetMarketEligibility")]
		private static extern SteamAPICall_t _GetMarketEligibility(IntPtr self);

		internal CallResult<MarketEligibilityResponse_t> GetMarketEligibility()
		{
			return new CallResult<MarketEligibilityResponse_t>(_GetMarketEligibility(Self), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUser_GetDurationControl")]
		private static extern SteamAPICall_t _GetDurationControl(IntPtr self);

		internal CallResult<DurationControl_t> GetDurationControl()
		{
			return new CallResult<DurationControl_t>(_GetDurationControl(Self), base.IsServer);
		}
	}
	internal class ISteamUserStats : SteamInterface
	{
		internal ISteamUserStats(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamUserStats_v011();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamUserStats_v011();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_RequestCurrentStats")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _RequestCurrentStats(IntPtr self);

		internal bool RequestCurrentStats()
		{
			return _RequestCurrentStats(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetStatInt32")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetStat(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, ref int pData);

		internal bool GetStat([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, ref int pData)
		{
			return _GetStat(Self, pchName, ref pData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetStatFloat")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetStat(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, ref float pData);

		internal bool GetStat([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, ref float pData)
		{
			return _GetStat(Self, pchName, ref pData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_SetStatInt32")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetStat(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, int nData);

		internal bool SetStat([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, int nData)
		{
			return _SetStat(Self, pchName, nData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_SetStatFloat")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetStat(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, float fData);

		internal bool SetStat([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, float fData)
		{
			return _SetStat(Self, pchName, fData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_UpdateAvgRateStat")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _UpdateAvgRateStat(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, float flCountThisSession, double dSessionLength);

		internal bool UpdateAvgRateStat([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, float flCountThisSession, double dSessionLength)
		{
			return _UpdateAvgRateStat(Self, pchName, flCountThisSession, dSessionLength);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetAchievement")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetAchievement(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, [MarshalAs(UnmanagedType.U1)] ref bool pbAchieved);

		internal bool GetAchievement([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, [MarshalAs(UnmanagedType.U1)] ref bool pbAchieved)
		{
			return _GetAchievement(Self, pchName, ref pbAchieved);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_SetAchievement")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _SetAchievement(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName);

		internal bool SetAchievement([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName)
		{
			return _SetAchievement(Self, pchName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_ClearAchievement")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ClearAchievement(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName);

		internal bool ClearAchievement([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName)
		{
			return _ClearAchievement(Self, pchName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetAchievementAndUnlockTime")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetAchievementAndUnlockTime(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, [MarshalAs(UnmanagedType.U1)] ref bool pbAchieved, ref uint punUnlockTime);

		internal bool GetAchievementAndUnlockTime([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, [MarshalAs(UnmanagedType.U1)] ref bool pbAchieved, ref uint punUnlockTime)
		{
			return _GetAchievementAndUnlockTime(Self, pchName, ref pbAchieved, ref punUnlockTime);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_StoreStats")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _StoreStats(IntPtr self);

		internal bool StoreStats()
		{
			return _StoreStats(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetAchievementIcon")]
		private static extern int _GetAchievementIcon(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName);

		internal int GetAchievementIcon([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName)
		{
			return _GetAchievementIcon(Self, pchName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute")]
		private static extern Utf8StringPointer _GetAchievementDisplayAttribute(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey);

		internal string GetAchievementDisplayAttribute([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey)
		{
			return _GetAchievementDisplayAttribute(Self, pchName, pchKey);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_IndicateAchievementProgress")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IndicateAchievementProgress(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, uint nCurProgress, uint nMaxProgress);

		internal bool IndicateAchievementProgress([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, uint nCurProgress, uint nMaxProgress)
		{
			return _IndicateAchievementProgress(Self, pchName, nCurProgress, nMaxProgress);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetNumAchievements")]
		private static extern uint _GetNumAchievements(IntPtr self);

		internal uint GetNumAchievements()
		{
			return _GetNumAchievements(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetAchievementName")]
		private static extern Utf8StringPointer _GetAchievementName(IntPtr self, uint iAchievement);

		internal string GetAchievementName(uint iAchievement)
		{
			return _GetAchievementName(Self, iAchievement);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_RequestUserStats")]
		private static extern SteamAPICall_t _RequestUserStats(IntPtr self, SteamId steamIDUser);

		internal CallResult<UserStatsReceived_t> RequestUserStats(SteamId steamIDUser)
		{
			return new CallResult<UserStatsReceived_t>(_RequestUserStats(Self, steamIDUser), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetUserStatInt32")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetUserStat(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, ref int pData);

		internal bool GetUserStat(SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, ref int pData)
		{
			return _GetUserStat(Self, steamIDUser, pchName, ref pData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetUserStatFloat")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetUserStat(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, ref float pData);

		internal bool GetUserStat(SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, ref float pData)
		{
			return _GetUserStat(Self, steamIDUser, pchName, ref pData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetUserAchievement")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetUserAchievement(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, [MarshalAs(UnmanagedType.U1)] ref bool pbAchieved);

		internal bool GetUserAchievement(SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, [MarshalAs(UnmanagedType.U1)] ref bool pbAchieved)
		{
			return _GetUserAchievement(Self, steamIDUser, pchName, ref pbAchieved);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetUserAchievementAndUnlockTime")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetUserAchievementAndUnlockTime(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, [MarshalAs(UnmanagedType.U1)] ref bool pbAchieved, ref uint punUnlockTime);

		internal bool GetUserAchievementAndUnlockTime(SteamId steamIDUser, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, [MarshalAs(UnmanagedType.U1)] ref bool pbAchieved, ref uint punUnlockTime)
		{
			return _GetUserAchievementAndUnlockTime(Self, steamIDUser, pchName, ref pbAchieved, ref punUnlockTime);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_ResetAllStats")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ResetAllStats(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bAchievementsToo);

		internal bool ResetAllStats([MarshalAs(UnmanagedType.U1)] bool bAchievementsToo)
		{
			return _ResetAllStats(Self, bAchievementsToo);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_FindOrCreateLeaderboard")]
		private static extern SteamAPICall_t _FindOrCreateLeaderboard(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchLeaderboardName, LeaderboardSort eLeaderboardSortMethod, LeaderboardDisplay eLeaderboardDisplayType);

		internal CallResult<LeaderboardFindResult_t> FindOrCreateLeaderboard([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchLeaderboardName, LeaderboardSort eLeaderboardSortMethod, LeaderboardDisplay eLeaderboardDisplayType)
		{
			return new CallResult<LeaderboardFindResult_t>(_FindOrCreateLeaderboard(Self, pchLeaderboardName, eLeaderboardSortMethod, eLeaderboardDisplayType), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_FindLeaderboard")]
		private static extern SteamAPICall_t _FindLeaderboard(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchLeaderboardName);

		internal CallResult<LeaderboardFindResult_t> FindLeaderboard([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchLeaderboardName)
		{
			return new CallResult<LeaderboardFindResult_t>(_FindLeaderboard(Self, pchLeaderboardName), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetLeaderboardName")]
		private static extern Utf8StringPointer _GetLeaderboardName(IntPtr self, SteamLeaderboard_t hSteamLeaderboard);

		internal string GetLeaderboardName(SteamLeaderboard_t hSteamLeaderboard)
		{
			return _GetLeaderboardName(Self, hSteamLeaderboard);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetLeaderboardEntryCount")]
		private static extern int _GetLeaderboardEntryCount(IntPtr self, SteamLeaderboard_t hSteamLeaderboard);

		internal int GetLeaderboardEntryCount(SteamLeaderboard_t hSteamLeaderboard)
		{
			return _GetLeaderboardEntryCount(Self, hSteamLeaderboard);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetLeaderboardSortMethod")]
		private static extern LeaderboardSort _GetLeaderboardSortMethod(IntPtr self, SteamLeaderboard_t hSteamLeaderboard);

		internal LeaderboardSort GetLeaderboardSortMethod(SteamLeaderboard_t hSteamLeaderboard)
		{
			return _GetLeaderboardSortMethod(Self, hSteamLeaderboard);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetLeaderboardDisplayType")]
		private static extern LeaderboardDisplay _GetLeaderboardDisplayType(IntPtr self, SteamLeaderboard_t hSteamLeaderboard);

		internal LeaderboardDisplay GetLeaderboardDisplayType(SteamLeaderboard_t hSteamLeaderboard)
		{
			return _GetLeaderboardDisplayType(Self, hSteamLeaderboard);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_DownloadLeaderboardEntries")]
		private static extern SteamAPICall_t _DownloadLeaderboardEntries(IntPtr self, SteamLeaderboard_t hSteamLeaderboard, LeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd);

		internal CallResult<LeaderboardScoresDownloaded_t> DownloadLeaderboardEntries(SteamLeaderboard_t hSteamLeaderboard, LeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd)
		{
			return new CallResult<LeaderboardScoresDownloaded_t>(_DownloadLeaderboardEntries(Self, hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_DownloadLeaderboardEntriesForUsers")]
		private static extern SteamAPICall_t _DownloadLeaderboardEntriesForUsers(IntPtr self, SteamLeaderboard_t hSteamLeaderboard, [In][Out] SteamId[] prgUsers, int cUsers);

		internal CallResult<LeaderboardScoresDownloaded_t> DownloadLeaderboardEntriesForUsers(SteamLeaderboard_t hSteamLeaderboard, [In][Out] SteamId[] prgUsers, int cUsers)
		{
			return new CallResult<LeaderboardScoresDownloaded_t>(_DownloadLeaderboardEntriesForUsers(Self, hSteamLeaderboard, prgUsers, cUsers), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetDownloadedLeaderboardEntry(IntPtr self, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, ref LeaderboardEntry_t pLeaderboardEntry, [In][Out] int[] pDetails, int cDetailsMax);

		internal bool GetDownloadedLeaderboardEntry(SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, ref LeaderboardEntry_t pLeaderboardEntry, [In][Out] int[] pDetails, int cDetailsMax)
		{
			return _GetDownloadedLeaderboardEntry(Self, hSteamLeaderboardEntries, index, ref pLeaderboardEntry, pDetails, cDetailsMax);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_UploadLeaderboardScore")]
		private static extern SteamAPICall_t _UploadLeaderboardScore(IntPtr self, SteamLeaderboard_t hSteamLeaderboard, LeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int nScore, [In][Out] int[] pScoreDetails, int cScoreDetailsCount);

		internal CallResult<LeaderboardScoreUploaded_t> UploadLeaderboardScore(SteamLeaderboard_t hSteamLeaderboard, LeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int nScore, [In][Out] int[] pScoreDetails, int cScoreDetailsCount)
		{
			return new CallResult<LeaderboardScoreUploaded_t>(_UploadLeaderboardScore(Self, hSteamLeaderboard, eLeaderboardUploadScoreMethod, nScore, pScoreDetails, cScoreDetailsCount), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_AttachLeaderboardUGC")]
		private static extern SteamAPICall_t _AttachLeaderboardUGC(IntPtr self, SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC);

		internal CallResult<LeaderboardUGCSet_t> AttachLeaderboardUGC(SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC)
		{
			return new CallResult<LeaderboardUGCSet_t>(_AttachLeaderboardUGC(Self, hSteamLeaderboard, hUGC), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetNumberOfCurrentPlayers")]
		private static extern SteamAPICall_t _GetNumberOfCurrentPlayers(IntPtr self);

		internal CallResult<NumberOfCurrentPlayers_t> GetNumberOfCurrentPlayers()
		{
			return new CallResult<NumberOfCurrentPlayers_t>(_GetNumberOfCurrentPlayers(Self), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_RequestGlobalAchievementPercentages")]
		private static extern SteamAPICall_t _RequestGlobalAchievementPercentages(IntPtr self);

		internal CallResult<GlobalAchievementPercentagesReady_t> RequestGlobalAchievementPercentages()
		{
			return new CallResult<GlobalAchievementPercentagesReady_t>(_RequestGlobalAchievementPercentages(Self), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetMostAchievedAchievementInfo")]
		private static extern int _GetMostAchievedAchievementInfo(IntPtr self, IntPtr pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs(UnmanagedType.U1)] ref bool pbAchieved);

		internal int GetMostAchievedAchievementInfo(out string pchName, ref float pflPercent, [MarshalAs(UnmanagedType.U1)] ref bool pbAchieved)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			int result = _GetMostAchievedAchievementInfo(Self, intPtr, 32768u, ref pflPercent, ref pbAchieved);
			pchName = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetNextMostAchievedAchievementInfo")]
		private static extern int _GetNextMostAchievedAchievementInfo(IntPtr self, int iIteratorPrevious, IntPtr pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs(UnmanagedType.U1)] ref bool pbAchieved);

		internal int GetNextMostAchievedAchievementInfo(int iIteratorPrevious, out string pchName, ref float pflPercent, [MarshalAs(UnmanagedType.U1)] ref bool pbAchieved)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			int result = _GetNextMostAchievedAchievementInfo(Self, iIteratorPrevious, intPtr, 32768u, ref pflPercent, ref pbAchieved);
			pchName = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetAchievementAchievedPercent")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetAchievementAchievedPercent(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, ref float pflPercent);

		internal bool GetAchievementAchievedPercent([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchName, ref float pflPercent)
		{
			return _GetAchievementAchievedPercent(Self, pchName, ref pflPercent);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_RequestGlobalStats")]
		private static extern SteamAPICall_t _RequestGlobalStats(IntPtr self, int nHistoryDays);

		internal CallResult<GlobalStatsReceived_t> RequestGlobalStats(int nHistoryDays)
		{
			return new CallResult<GlobalStatsReceived_t>(_RequestGlobalStats(Self, nHistoryDays), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetGlobalStatInt64")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetGlobalStat(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchStatName, ref long pData);

		internal bool GetGlobalStat([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchStatName, ref long pData)
		{
			return _GetGlobalStat(Self, pchStatName, ref pData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetGlobalStatDouble")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetGlobalStat(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchStatName, ref double pData);

		internal bool GetGlobalStat([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchStatName, ref double pData)
		{
			return _GetGlobalStat(Self, pchStatName, ref pData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetGlobalStatHistoryInt64")]
		private static extern int _GetGlobalStatHistory(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchStatName, [In][Out] long[] pData, uint cubData);

		internal int GetGlobalStatHistory([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchStatName, [In][Out] long[] pData, uint cubData)
		{
			return _GetGlobalStatHistory(Self, pchStatName, pData, cubData);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUserStats_GetGlobalStatHistoryDouble")]
		private static extern int _GetGlobalStatHistory(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchStatName, [In][Out] double[] pData, uint cubData);

		internal int GetGlobalStatHistory([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchStatName, [In][Out] double[] pData, uint cubData)
		{
			return _GetGlobalStatHistory(Self, pchStatName, pData, cubData);
		}
	}
	internal class ISteamUtils : SteamInterface
	{
		internal ISteamUtils(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamUtils_v009();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamUtils_v009();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamGameServerUtils_v009();

		public override IntPtr GetServerInterfacePointer()
		{
			return SteamAPI_SteamGameServerUtils_v009();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetSecondsSinceAppActive")]
		private static extern uint _GetSecondsSinceAppActive(IntPtr self);

		internal uint GetSecondsSinceAppActive()
		{
			return _GetSecondsSinceAppActive(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetSecondsSinceComputerActive")]
		private static extern uint _GetSecondsSinceComputerActive(IntPtr self);

		internal uint GetSecondsSinceComputerActive()
		{
			return _GetSecondsSinceComputerActive(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetConnectedUniverse")]
		private static extern Universe _GetConnectedUniverse(IntPtr self);

		internal Universe GetConnectedUniverse()
		{
			return _GetConnectedUniverse(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetServerRealTime")]
		private static extern uint _GetServerRealTime(IntPtr self);

		internal uint GetServerRealTime()
		{
			return _GetServerRealTime(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetIPCountry")]
		private static extern Utf8StringPointer _GetIPCountry(IntPtr self);

		internal string GetIPCountry()
		{
			return _GetIPCountry(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetImageSize")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetImageSize(IntPtr self, int iImage, ref uint pnWidth, ref uint pnHeight);

		internal bool GetImageSize(int iImage, ref uint pnWidth, ref uint pnHeight)
		{
			return _GetImageSize(Self, iImage, ref pnWidth, ref pnHeight);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetImageRGBA")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetImageRGBA(IntPtr self, int iImage, [In][Out] byte[] pubDest, int nDestBufferSize);

		internal bool GetImageRGBA(int iImage, [In][Out] byte[] pubDest, int nDestBufferSize)
		{
			return _GetImageRGBA(Self, iImage, pubDest, nDestBufferSize);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetCSERIPPort")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetCSERIPPort(IntPtr self, ref uint unIP, ref ushort usPort);

		internal bool GetCSERIPPort(ref uint unIP, ref ushort usPort)
		{
			return _GetCSERIPPort(Self, ref unIP, ref usPort);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetCurrentBatteryPower")]
		private static extern byte _GetCurrentBatteryPower(IntPtr self);

		internal byte GetCurrentBatteryPower()
		{
			return _GetCurrentBatteryPower(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetAppID")]
		private static extern uint _GetAppID(IntPtr self);

		internal uint GetAppID()
		{
			return _GetAppID(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_SetOverlayNotificationPosition")]
		private static extern void _SetOverlayNotificationPosition(IntPtr self, NotificationPosition eNotificationPosition);

		internal void SetOverlayNotificationPosition(NotificationPosition eNotificationPosition)
		{
			_SetOverlayNotificationPosition(Self, eNotificationPosition);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_IsAPICallCompleted")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsAPICallCompleted(IntPtr self, SteamAPICall_t hSteamAPICall, [MarshalAs(UnmanagedType.U1)] ref bool pbFailed);

		internal bool IsAPICallCompleted(SteamAPICall_t hSteamAPICall, [MarshalAs(UnmanagedType.U1)] ref bool pbFailed)
		{
			return _IsAPICallCompleted(Self, hSteamAPICall, ref pbFailed);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetAPICallFailureReason")]
		private static extern SteamAPICallFailure _GetAPICallFailureReason(IntPtr self, SteamAPICall_t hSteamAPICall);

		internal SteamAPICallFailure GetAPICallFailureReason(SteamAPICall_t hSteamAPICall)
		{
			return _GetAPICallFailureReason(Self, hSteamAPICall);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetAPICallResult")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetAPICallResult(IntPtr self, SteamAPICall_t hSteamAPICall, IntPtr pCallback, int cubCallback, int iCallbackExpected, [MarshalAs(UnmanagedType.U1)] ref bool pbFailed);

		internal bool GetAPICallResult(SteamAPICall_t hSteamAPICall, IntPtr pCallback, int cubCallback, int iCallbackExpected, [MarshalAs(UnmanagedType.U1)] ref bool pbFailed)
		{
			return _GetAPICallResult(Self, hSteamAPICall, pCallback, cubCallback, iCallbackExpected, ref pbFailed);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetIPCCallCount")]
		private static extern uint _GetIPCCallCount(IntPtr self);

		internal uint GetIPCCallCount()
		{
			return _GetIPCCallCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_SetWarningMessageHook")]
		private static extern void _SetWarningMessageHook(IntPtr self, IntPtr pFunction);

		internal void SetWarningMessageHook(IntPtr pFunction)
		{
			_SetWarningMessageHook(Self, pFunction);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_IsOverlayEnabled")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsOverlayEnabled(IntPtr self);

		internal bool IsOverlayEnabled()
		{
			return _IsOverlayEnabled(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_BOverlayNeedsPresent")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BOverlayNeedsPresent(IntPtr self);

		internal bool BOverlayNeedsPresent()
		{
			return _BOverlayNeedsPresent(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_CheckFileSignature")]
		private static extern SteamAPICall_t _CheckFileSignature(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string szFileName);

		internal CallResult<CheckFileSignature_t> CheckFileSignature([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string szFileName)
		{
			return new CallResult<CheckFileSignature_t>(_CheckFileSignature(Self, szFileName), base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_ShowGamepadTextInput")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ShowGamepadTextInput(IntPtr self, GamepadTextInputMode eInputMode, GamepadTextInputLineMode eLineInputMode, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchDescription, uint unCharMax, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchExistingText);

		internal bool ShowGamepadTextInput(GamepadTextInputMode eInputMode, GamepadTextInputLineMode eLineInputMode, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchDescription, uint unCharMax, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchExistingText)
		{
			return _ShowGamepadTextInput(Self, eInputMode, eLineInputMode, pchDescription, unCharMax, pchExistingText);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetEnteredGamepadTextLength")]
		private static extern uint _GetEnteredGamepadTextLength(IntPtr self);

		internal uint GetEnteredGamepadTextLength()
		{
			return _GetEnteredGamepadTextLength(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetEnteredGamepadTextInput")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetEnteredGamepadTextInput(IntPtr self, IntPtr pchText, uint cchText);

		internal bool GetEnteredGamepadTextInput(out string pchText)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _GetEnteredGamepadTextInput(Self, intPtr, 32768u);
			pchText = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetSteamUILanguage")]
		private static extern Utf8StringPointer _GetSteamUILanguage(IntPtr self);

		internal string GetSteamUILanguage()
		{
			return _GetSteamUILanguage(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_IsSteamRunningInVR")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsSteamRunningInVR(IntPtr self);

		internal bool IsSteamRunningInVR()
		{
			return _IsSteamRunningInVR(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_SetOverlayNotificationInset")]
		private static extern void _SetOverlayNotificationInset(IntPtr self, int nHorizontalInset, int nVerticalInset);

		internal void SetOverlayNotificationInset(int nHorizontalInset, int nVerticalInset)
		{
			_SetOverlayNotificationInset(Self, nHorizontalInset, nVerticalInset);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_IsSteamInBigPictureMode")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsSteamInBigPictureMode(IntPtr self);

		internal bool IsSteamInBigPictureMode()
		{
			return _IsSteamInBigPictureMode(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_StartVRDashboard")]
		private static extern void _StartVRDashboard(IntPtr self);

		internal void StartVRDashboard()
		{
			_StartVRDashboard(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_IsVRHeadsetStreamingEnabled")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsVRHeadsetStreamingEnabled(IntPtr self);

		internal bool IsVRHeadsetStreamingEnabled()
		{
			return _IsVRHeadsetStreamingEnabled(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_SetVRHeadsetStreamingEnabled")]
		private static extern void _SetVRHeadsetStreamingEnabled(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bEnabled);

		internal void SetVRHeadsetStreamingEnabled([MarshalAs(UnmanagedType.U1)] bool bEnabled)
		{
			_SetVRHeadsetStreamingEnabled(Self, bEnabled);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_IsSteamChinaLauncher")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsSteamChinaLauncher(IntPtr self);

		internal bool IsSteamChinaLauncher()
		{
			return _IsSteamChinaLauncher(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_InitFilterText")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _InitFilterText(IntPtr self);

		internal bool InitFilterText()
		{
			return _InitFilterText(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_FilterText")]
		private static extern int _FilterText(IntPtr self, IntPtr pchOutFilteredText, uint nByteSizeOutFilteredText, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchInputMessage, [MarshalAs(UnmanagedType.U1)] bool bLegalOnly);

		internal int FilterText(out string pchOutFilteredText, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchInputMessage, [MarshalAs(UnmanagedType.U1)] bool bLegalOnly)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			int result = _FilterText(Self, intPtr, 32768u, pchInputMessage, bLegalOnly);
			pchOutFilteredText = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamUtils_GetIPv6ConnectivityState")]
		private static extern SteamIPv6ConnectivityState _GetIPv6ConnectivityState(IntPtr self, SteamIPv6ConnectivityProtocol eProtocol);

		internal SteamIPv6ConnectivityState GetIPv6ConnectivityState(SteamIPv6ConnectivityProtocol eProtocol)
		{
			return _GetIPv6ConnectivityState(Self, eProtocol);
		}
	}
	internal class ISteamVideo : SteamInterface
	{
		internal ISteamVideo(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamVideo_v002();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamVideo_v002();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamVideo_GetVideoURL")]
		private static extern void _GetVideoURL(IntPtr self, AppId unVideoAppID);

		internal void GetVideoURL(AppId unVideoAppID)
		{
			_GetVideoURL(Self, unVideoAppID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamVideo_IsBroadcasting")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsBroadcasting(IntPtr self, ref int pnNumViewers);

		internal bool IsBroadcasting(ref int pnNumViewers)
		{
			return _IsBroadcasting(Self, ref pnNumViewers);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamVideo_GetOPFSettings")]
		private static extern void _GetOPFSettings(IntPtr self, AppId unVideoAppID);

		internal void GetOPFSettings(AppId unVideoAppID)
		{
			_GetOPFSettings(Self, unVideoAppID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamVideo_GetOPFStringForApp")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetOPFStringForApp(IntPtr self, AppId unVideoAppID, IntPtr pchBuffer, ref int pnBufferSize);

		internal bool GetOPFStringForApp(AppId unVideoAppID, out string pchBuffer, ref int pnBufferSize)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _GetOPFStringForApp(Self, unVideoAppID, intPtr, ref pnBufferSize);
			pchBuffer = Helpers.MemoryToString(intPtr);
			return result;
		}
	}
	internal enum SteamIPType
	{
		Type4,
		Type6
	}
	public enum Universe
	{
		Invalid,
		Public,
		Beta,
		Internal,
		Dev,
		Max
	}
	public enum Result
	{
		None = 0,
		OK = 1,
		Fail = 2,
		NoConnection = 3,
		InvalidPassword = 5,
		LoggedInElsewhere = 6,
		InvalidProtocolVer = 7,
		InvalidParam = 8,
		FileNotFound = 9,
		Busy = 10,
		InvalidState = 11,
		InvalidName = 12,
		InvalidEmail = 13,
		DuplicateName = 14,
		AccessDenied = 15,
		Timeout = 16,
		Banned = 17,
		AccountNotFound = 18,
		InvalidSteamID = 19,
		ServiceUnavailable = 20,
		NotLoggedOn = 21,
		Pending = 22,
		EncryptionFailure = 23,
		InsufficientPrivilege = 24,
		LimitExceeded = 25,
		Revoked = 26,
		Expired = 27,
		AlreadyRedeemed = 28,
		DuplicateRequest = 29,
		AlreadyOwned = 30,
		IPNotFound = 31,
		PersistFailed = 32,
		LockingFailed = 33,
		LogonSessionReplaced = 34,
		ConnectFailed = 35,
		HandshakeFailed = 36,
		IOFailure = 37,
		RemoteDisconnect = 38,
		ShoppingCartNotFound = 39,
		Blocked = 40,
		Ignored = 41,
		NoMatch = 42,
		AccountDisabled = 43,
		ServiceReadOnly = 44,
		AccountNotFeatured = 45,
		AdministratorOK = 46,
		ContentVersion = 47,
		TryAnotherCM = 48,
		PasswordRequiredToKickSession = 49,
		AlreadyLoggedInElsewhere = 50,
		Suspended = 51,
		Cancelled = 52,
		DataCorruption = 53,
		DiskFull = 54,
		RemoteCallFailed = 55,
		PasswordUnset = 56,
		ExternalAccountUnlinked = 57,
		PSNTicketInvalid = 58,
		ExternalAccountAlreadyLinked = 59,
		RemoteFileConflict = 60,
		IllegalPassword = 61,
		SameAsPreviousValue = 62,
		AccountLogonDenied = 63,
		CannotUseOldPassword = 64,
		InvalidLoginAuthCode = 65,
		AccountLogonDeniedNoMail = 66,
		HardwareNotCapableOfIPT = 67,
		IPTInitError = 68,
		ParentalControlRestricted = 69,
		FacebookQueryError = 70,
		ExpiredLoginAuthCode = 71,
		IPLoginRestrictionFailed = 72,
		AccountLockedDown = 73,
		AccountLogonDeniedVerifiedEmailRequired = 74,
		NoMatchingURL = 75,
		BadResponse = 76,
		RequirePasswordReEntry = 77,
		ValueOutOfRange = 78,
		UnexpectedError = 79,
		Disabled = 80,
		InvalidCEGSubmission = 81,
		RestrictedDevice = 82,
		RegionLocked = 83,
		RateLimitExceeded = 84,
		AccountLoginDeniedNeedTwoFactor = 85,
		ItemDeleted = 86,
		AccountLoginDeniedThrottle = 87,
		TwoFactorCodeMismatch = 88,
		TwoFactorActivationCodeMismatch = 89,
		AccountAssociatedToMultiplePartners = 90,
		NotModified = 91,
		NoMobileDevice = 92,
		TimeNotSynced = 93,
		SmsCodeFailed = 94,
		AccountLimitExceeded = 95,
		AccountActivityLimitExceeded = 96,
		PhoneActivityLimitExceeded = 97,
		RefundToWallet = 98,
		EmailSendFailure = 99,
		NotSettled = 100,
		NeedCaptcha = 101,
		GSLTDenied = 102,
		GSOwnerDenied = 103,
		InvalidItemType = 104,
		IPBanned = 105,
		GSLTExpired = 106,
		InsufficientFunds = 107,
		TooManyPending = 108,
		NoSiteLicensesFound = 109,
		WGNetworkSendExceeded = 110,
		AccountNotFriends = 111,
		LimitedUserAccount = 112,
		CantRemoveItem = 113,
		AccountDeleted = 114,
		ExistingUserCancelledLicense = 115
	}
	internal enum VoiceResult
	{
		OK,
		NotInitialized,
		NotRecording,
		NoData,
		BufferTooSmall,
		DataCorrupted,
		Restricted,
		UnsupportedCodec,
		ReceiverOutOfDate,
		ReceiverDidNotAnswer
	}
	internal enum DenyReason
	{
		Invalid,
		InvalidVersion,
		Generic,
		NotLoggedOn,
		NoLicense,
		Cheater,
		LoggedInElseWhere,
		UnknownText,
		IncompatibleAnticheat,
		MemoryCorruption,
		IncompatibleSoftware,
		SteamConnectionLost,
		SteamConnectionError,
		SteamResponseTimedOut,
		SteamValidationStalled,
		SteamOwnerLeftGuestUser
	}
	public enum BeginAuthResult
	{
		OK,
		InvalidTicket,
		DuplicateRequest,
		InvalidVersion,
		GameMismatch,
		ExpiredTicket
	}
	public enum AuthResponse
	{
		OK,
		UserNotConnectedToSteam,
		NoLicenseOrExpired,
		VACBanned,
		LoggedInElseWhere,
		VACCheckTimedOut,
		AuthTicketCanceled,
		AuthTicketInvalidAlreadyUsed,
		AuthTicketInvalid,
		PublisherIssuedBan
	}
	public enum UserHasLicenseForAppResult
	{
		HasLicense,
		DoesNotHaveLicense,
		NoAuth
	}
	internal enum AccountType
	{
		Invalid,
		Individual,
		Multiseat,
		GameServer,
		AnonGameServer,
		Pending,
		ContentServer,
		Clan,
		Chat,
		ConsoleUser,
		AnonUser,
		Max
	}
	internal enum AppReleaseState
	{
		Unknown,
		Unavailable,
		Prerelease,
		PreloadOnly,
		Released
	}
	internal enum AppOwnershipFlags
	{
		None = 0,
		OwnsLicense = 1,
		FreeLicense = 2,
		RegionRestricted = 4,
		LowViolence = 8,
		InvalidPlatform = 0x10,
		SharedLicense = 0x20,
		FreeWeekend = 0x40,
		RetailLicense = 0x80,
		LicenseLocked = 0x100,
		LicensePending = 0x200,
		LicenseExpired = 0x400,
		LicensePermanent = 0x800,
		LicenseRecurring = 0x1000,
		LicenseCanceled = 0x2000,
		AutoGrant = 0x4000,
		PendingGift = 0x8000,
		RentalNotActivated = 0x10000,
		Rental = 0x20000,
		SiteLicense = 0x40000,
		LegacyFreeSub = 0x80000,
		InvalidOSType = 0x100000
	}
	internal enum AppType
	{
		Invalid = 0,
		Game = 1,
		Application = 2,
		Tool = 4,
		Demo = 8,
		Media_DEPRECATED = 16,
		DLC = 32,
		Guide = 64,
		Driver = 128,
		Config = 256,
		Hardware = 512,
		Franchise = 1024,
		Video = 2048,
		Plugin = 4096,
		MusicAlbum = 8192,
		Series = 16384,
		Comic_UNUSED = 32768,
		Beta = 65536,
		Shortcut = 1073741824,
		DepotOnly = int.MinValue
	}
	internal enum SteamUserStatType
	{
		INVALID,
		INT,
		FLOAT,
		AVGRATE,
		ACHIEVEMENTS,
		GROUPACHIEVEMENTS,
		MAX
	}
	internal enum ChatEntryType
	{
		Invalid = 0,
		ChatMsg = 1,
		Typing = 2,
		InviteGame = 3,
		Emote = 4,
		LeftConversation = 6,
		Entered = 7,
		WasKicked = 8,
		WasBanned = 9,
		Disconnected = 10,
		HistoricalChat = 11,
		LinkBlocked = 14
	}
	public enum RoomEnter
	{
		Success = 1,
		DoesntExist = 2,
		NotAllowed = 3,
		Full = 4,
		Error = 5,
		Banned = 6,
		Limited = 7,
		ClanDisabled = 8,
		CommunityBan = 9,
		MemberBlockedYou = 10,
		YouBlockedMember = 11,
		RatelimitExceeded = 15
	}
	internal enum ChatSteamIDInstanceFlags
	{
		AccountInstanceMask = 4095,
		InstanceFlagClan = 524288,
		InstanceFlagLobby = 262144,
		InstanceFlagMMSLobby = 131072
	}
	internal enum MarketingMessageFlags
	{
		None = 0,
		HighPriority = 1,
		PlatformWindows = 2,
		PlatformMac = 4,
		PlatformLinux = 8,
		PlatformRestrictions = 14
	}
	public enum NotificationPosition
	{
		TopLeft,
		TopRight,
		BottomLeft,
		BottomRight
	}
	public enum BroadcastUploadResult
	{
		None,
		OK,
		InitFailed,
		FrameFailed,
		Timeout,
		BandwidthExceeded,
		LowFPS,
		MissingKeyFrames,
		NoConnection,
		RelayFailed,
		SettingsChanged,
		MissingAudio,
		TooFarBehind,
		TranscodeBehind,
		NotAllowedToPlay,
		Busy,
		Banned,
		AlreadyActive,
		ForcedOff,
		AudioBehind,
		Shutdown,
		Disconnect,
		VideoInitFailed,
		AudioInitFailed
	}
	internal enum LaunchOptionType
	{
		None = 0,
		Default = 1,
		SafeMode = 2,
		Multiplayer = 3,
		Config = 4,
		OpenVR = 5,
		Server = 6,
		Editor = 7,
		Manual = 8,
		Benchmark = 9,
		Option1 = 10,
		Option2 = 11,
		Option3 = 12,
		OculusVR = 13,
		OpenVROverlay = 14,
		OSVR = 15,
		Dialog = 1000
	}
	internal enum VRHMDType
	{
		MDType_None = -1,
		MDType_Unknown = 0,
		MDType_HTC_Dev = 1,
		MDType_HTC_VivePre = 2,
		MDType_HTC_Vive = 3,
		MDType_HTC_VivePro = 4,
		MDType_HTC_ViveCosmos = 5,
		MDType_HTC_Unknown = 20,
		MDType_Oculus_DK1 = 21,
		MDType_Oculus_DK2 = 22,
		MDType_Oculus_Rift = 23,
		MDType_Oculus_RiftS = 24,
		MDType_Oculus_Quest = 25,
		MDType_Oculus_Unknown = 40,
		MDType_Acer_Unknown = 50,
		MDType_Acer_WindowsMR = 51,
		MDType_Dell_Unknown = 60,
		MDType_Dell_Visor = 61,
		MDType_Lenovo_Unknown = 70,
		MDType_Lenovo_Explorer = 71,
		MDType_HP_Unknown = 80,
		MDType_HP_WindowsMR = 81,
		MDType_HP_Reverb = 82,
		MDType_Samsung_Unknown = 90,
		MDType_Samsung_Odyssey = 91,
		MDType_Unannounced_Unknown = 100,
		MDType_Unannounced_WindowsMR = 101,
		MDType_vridge = 110,
		MDType_Huawei_Unknown = 120,
		MDType_Huawei_VR2 = 121,
		MDType_Huawei_EndOfRange = 129,
		mdType_Valve_Unknown = 130,
		mdType_Valve_Index = 131
	}
	internal enum MarketNotAllowedReasonFlags
	{
		None = 0,
		TemporaryFailure = 1,
		AccountDisabled = 2,
		AccountLockedDown = 4,
		AccountLimited = 8,
		TradeBanned = 0x10,
		AccountNotTrusted = 0x20,
		SteamGuardNotEnabled = 0x40,
		SteamGuardOnlyRecentlyEnabled = 0x80,
		RecentPasswordReset = 0x100,
		NewPaymentMethod = 0x200,
		InvalidCookie = 0x400,
		UsingNewDevice = 0x800,
		RecentSelfRefund = 0x1000,
		NewPaymentMethodCannotBeVerified = 0x2000,
		NoRecentPurchases = 0x4000,
		AcceptedWalletGift = 0x8000
	}
	public enum DurationControlProgress
	{
		Progress_Full,
		Progress_Half,
		Progress_None,
		ExitSoon_3h,
		ExitSoon_5h,
		ExitSoon_Night
	}
	internal enum DurationControlNotification
	{
		None,
		DurationControlNotification1Hour,
		DurationControlNotification3Hours,
		HalfProgress,
		NoProgress,
		ExitSoon_3h,
		ExitSoon_5h,
		ExitSoon_Night
	}
	internal enum GameSearchErrorCode_t
	{
		OK = 1,
		Failed_Search_Already_In_Progress,
		Failed_No_Search_In_Progress,
		Failed_Not_Lobby_Leader,
		Failed_No_Host_Available,
		Failed_Search_Params_Invalid,
		Failed_Offline,
		Failed_NotAuthorized,
		Failed_Unknown_Error
	}
	internal enum PlayerResult_t
	{
		FailedToConnect = 1,
		Abandoned,
		Kicked,
		Incomplete,
		Completed
	}
	internal enum SteamIPv6ConnectivityProtocol
	{
		Invalid,
		HTTP,
		UDP
	}
	internal enum SteamIPv6ConnectivityState
	{
		Unknown,
		Good,
		Bad
	}
	public enum Relationship
	{
		None,
		Blocked,
		RequestRecipient,
		Friend,
		RequestInitiator,
		Ignored,
		IgnoredFriend,
		Suggested_DEPRECATED,
		Max
	}
	public enum FriendState
	{
		Offline,
		Online,
		Busy,
		Away,
		Snooze,
		LookingToTrade,
		LookingToPlay,
		Invisible,
		Max
	}
	internal enum FriendFlags
	{
		None = 0,
		Blocked = 1,
		FriendshipRequested = 2,
		Immediate = 4,
		ClanMember = 8,
		OnGameServer = 16,
		RequestingFriendship = 128,
		RequestingInfo = 256,
		Ignored = 512,
		IgnoredFriend = 1024,
		ChatMember = 4096,
		All = 65535
	}
	internal enum UserRestriction
	{
		None = 0,
		Unknown = 1,
		AnyChat = 2,
		VoiceChat = 4,
		GroupChat = 8,
		Rating = 0x10,
		GameInvites = 0x20,
		Trading = 0x40
	}
	internal enum OverlayToStoreFlag
	{
		None,
		AddToCart,
		AddToCartAndShow
	}
	internal enum ActivateGameOverlayToWebPageMode
	{
		Default,
		Modal
	}
	internal enum PersonaChange
	{
		Name = 1,
		Status = 2,
		ComeOnline = 4,
		GoneOffline = 8,
		GamePlayed = 0x10,
		GameServer = 0x20,
		Avatar = 0x40,
		JoinedSource = 0x80,
		LeftSource = 0x100,
		RelationshipChanged = 0x200,
		NameFirstSet = 0x400,
		Broadcast = 0x800,
		Nickname = 0x1000,
		SteamLevel = 0x2000,
		RichPresence = 0x4000
	}
	internal enum SteamAPICallFailure
	{
		None = -1,
		SteamGone,
		NetworkFailure,
		InvalidHandle,
		MismatchedCallback
	}
	public enum GamepadTextInputMode
	{
		Normal,
		Password
	}
	public enum GamepadTextInputLineMode
	{
		SingleLine,
		MultipleLines
	}
	public enum CheckFileSignature
	{
		InvalidSignature,
		ValidSignature,
		FileNotFound,
		NoSignaturesFoundForThisApp,
		NoSignaturesFoundForThisFile
	}
	internal enum MatchMakingServerResponse
	{
		ServerResponded,
		ServerFailedToRespond,
		NoServersListedOnMasterServer
	}
	internal enum LobbyType
	{
		Private,
		FriendsOnly,
		Public,
		Invisible,
		PrivateUnique
	}
	internal enum LobbyComparison
	{
		EqualToOrLessThan = -2,
		LessThan,
		Equal,
		GreaterThan,
		EqualToOrGreaterThan,
		NotEqual
	}
	internal enum LobbyDistanceFilter
	{
		Close,
		Default,
		Far,
		Worldwide
	}
	internal enum ChatMemberStateChange
	{
		Entered = 1,
		Left = 2,
		Disconnected = 4,
		Kicked = 8,
		Banned = 0x10
	}
	internal enum SteamPartyBeaconLocationType
	{
		Invalid,
		ChatGroup,
		Max
	}
	internal enum SteamPartyBeaconLocationData
	{
		Invalid,
		Name,
		IconURLSmall,
		IconURLMedium,
		IconURLLarge
	}
	internal enum RemoteStoragePlatform
	{
		None = 0,
		Windows = 1,
		OSX = 2,
		PS3 = 4,
		Linux = 8,
		Switch = 16,
		Android = 32,
		IOS = 64,
		All = -1
	}
	internal enum RemoteStoragePublishedFileVisibility
	{
		Public,
		FriendsOnly,
		Private,
		Unlisted
	}
	internal enum WorkshopFileType
	{
		First = 0,
		Community = 0,
		Microtransaction = 1,
		Collection = 2,
		Art = 3,
		Video = 4,
		Screenshot = 5,
		Game = 6,
		Software = 7,
		Concept = 8,
		WebGuide = 9,
		IntegratedGuide = 10,
		Merch = 11,
		ControllerBinding = 12,
		SteamworksAccessInvite = 13,
		SteamVideo = 14,
		GameManagedItem = 15,
		Max = 16
	}
	internal enum WorkshopVote
	{
		Unvoted,
		For,
		Against,
		Later
	}
	internal enum WorkshopFileAction
	{
		Played,
		Completed
	}
	internal enum WorkshopEnumerationType
	{
		RankedByVote,
		Recent,
		Trending,
		FavoritesOfFriends,
		VotedByFriends,
		ContentByFriends,
		RecentFromFollowedUsers
	}
	internal enum WorkshopVideoProvider
	{
		None,
		Youtube
	}
	internal enum UGCReadAction
	{
		ontinueReadingUntilFinished,
		ontinueReading,
		lose
	}
	internal enum LeaderboardDataRequest
	{
		Global,
		GlobalAroundUser,
		Friends,
		Users
	}
	internal enum LeaderboardUploadScoreMethod
	{
		None,
		KeepBest,
		ForceUpdate
	}
	internal enum RegisterActivationCodeResult
	{
		ResultOK,
		ResultFail,
		ResultAlreadyRegistered,
		ResultTimeout,
		AlreadyOwned
	}
	public enum P2PSessionError
	{
		None,
		NotRunningApp,
		NoRightsToApp,
		DestinationNotLoggedIn,
		Timeout,
		Max
	}
	public enum P2PSend
	{
		Unreliable,
		UnreliableNoDelay,
		Reliable,
		ReliableWithBuffering
	}
	internal enum VRScreenshotType
	{
		None,
		Mono,
		Stereo,
		MonoCubemap,
		MonoPanorama,
		StereoPanorama
	}
	public enum MusicStatus
	{
		Undefined,
		Playing,
		Paused,
		Idle
	}
	internal enum HTTPMethod
	{
		Invalid,
		GET,
		HEAD,
		POST,
		PUT,
		DELETE,
		OPTIONS,
		PATCH
	}
	internal enum HTTPStatusCode
	{
		Invalid = 0,
		Code100Continue = 100,
		Code101SwitchingProtocols = 101,
		Code200OK = 200,
		Code201Created = 201,
		Code202Accepted = 202,
		Code203NonAuthoritative = 203,
		Code204NoContent = 204,
		Code205ResetContent = 205,
		Code206PartialContent = 206,
		Code300MultipleChoices = 300,
		Code301MovedPermanently = 301,
		Code302Found = 302,
		Code303SeeOther = 303,
		Code304NotModified = 304,
		Code305UseProxy = 305,
		Code307TemporaryRedirect = 307,
		Code400BadRequest = 400,
		Code401Unauthorized = 401,
		Code402PaymentRequired = 402,
		Code403Forbidden = 403,
		Code404NotFound = 404,
		Code405MethodNotAllowed = 405,
		Code406NotAcceptable = 406,
		Code407ProxyAuthRequired = 407,
		Code408RequestTimeout = 408,
		Code409Conflict = 409,
		Code410Gone = 410,
		Code411LengthRequired = 411,
		Code412PreconditionFailed = 412,
		Code413RequestEntityTooLarge = 413,
		Code414RequestURITooLong = 414,
		Code415UnsupportedMediaType = 415,
		Code416RequestedRangeNotSatisfiable = 416,
		Code417ExpectationFailed = 417,
		Code4xxUnknown = 418,
		Code429TooManyRequests = 429,
		Code500InternalServerError = 500,
		Code501NotImplemented = 501,
		Code502BadGateway = 502,
		Code503ServiceUnavailable = 503,
		Code504GatewayTimeout = 504,
		Code505HTTPVersionNotSupported = 505,
		Code5xxUnknown = 599
	}
	public enum InputSourceMode
	{
		None,
		Dpad,
		Buttons,
		FourButtons,
		AbsoluteMouse,
		RelativeMouse,
		JoystickMove,
		JoystickMouse,
		JoystickCamera,
		ScrollWheel,
		Trigger,
		TouchMenu,
		MouseJoystick,
		MouseRegion,
		RadialMenu,
		SingleButton,
		Switches
	}
	internal enum InputActionOrigin
	{
		None = 0,
		SteamController_A = 1,
		SteamController_B = 2,
		SteamController_X = 3,
		SteamController_Y = 4,
		SteamController_LeftBumper = 5,
		SteamController_RightBumper = 6,
		SteamController_LeftGrip = 7,
		SteamController_RightGrip = 8,
		SteamController_Start = 9,
		SteamController_Back = 10,
		SteamController_LeftPad_Touch = 11,
		SteamController_LeftPad_Swipe = 12,
		SteamController_LeftPad_Click = 13,
		SteamController_LeftPad_DPadNorth = 14,
		SteamController_LeftPad_DPadSouth = 15,
		SteamController_LeftPad_DPadWest = 16,
		SteamController_LeftPad_DPadEast = 17,
		SteamController_RightPad_Touch = 18,
		SteamController_RightPad_Swipe = 19,
		SteamController_RightPad_Click = 20,
		SteamController_RightPad_DPadNorth = 21,
		SteamController_RightPad_DPadSouth = 22,
		SteamController_RightPad_DPadWest = 23,
		SteamController_RightPad_DPadEast = 24,
		SteamController_LeftTrigger_Pull = 25,
		SteamController_LeftTrigger_Click = 26,
		SteamController_RightTrigger_Pull = 27,
		SteamController_RightTrigger_Click = 28,
		SteamController_LeftStick_Move = 29,
		SteamController_LeftStick_Click = 30,
		SteamController_LeftStick_DPadNorth = 31,
		SteamController_LeftStick_DPadSouth = 32,
		SteamController_LeftStick_DPadWest = 33,
		SteamController_LeftStick_DPadEast = 34,
		SteamController_Gyro_Move = 35,
		SteamController_Gyro_Pitch = 36,
		SteamController_Gyro_Yaw = 37,
		SteamController_Gyro_Roll = 38,
		SteamController_Reserved0 = 39,
		SteamController_Reserved1 = 40,
		SteamController_Reserved2 = 41,
		SteamController_Reserved3 = 42,
		SteamController_Reserved4 = 43,
		SteamController_Reserved5 = 44,
		SteamController_Reserved6 = 45,
		SteamController_Reserved7 = 46,
		SteamController_Reserved8 = 47,
		SteamController_Reserved9 = 48,
		SteamController_Reserved10 = 49,
		PS4_X = 50,
		PS4_Circle = 51,
		PS4_Triangle = 52,
		PS4_Square = 53,
		PS4_LeftBumper = 54,
		PS4_RightBumper = 55,
		PS4_Options = 56,
		PS4_Share = 57,
		PS4_LeftPad_Touch = 58,
		PS4_LeftPad_Swipe = 59,
		PS4_LeftPad_Click = 60,
		PS4_LeftPad_DPadNorth = 61,
		PS4_LeftPad_DPadSouth = 62,
		PS4_LeftPad_DPadWest = 63,
		PS4_LeftPad_DPadEast = 64,
		PS4_RightPad_Touch = 65,
		PS4_RightPad_Swipe = 66,
		PS4_RightPad_Click = 67,
		PS4_RightPad_DPadNorth = 68,
		PS4_RightPad_DPadSouth = 69,
		PS4_RightPad_DPadWest = 70,
		PS4_RightPad_DPadEast = 71,
		PS4_CenterPad_Touch = 72,
		PS4_CenterPad_Swipe = 73,
		PS4_CenterPad_Click = 74,
		PS4_CenterPad_DPadNorth = 75,
		PS4_CenterPad_DPadSouth = 76,
		PS4_CenterPad_DPadWest = 77,
		PS4_CenterPad_DPadEast = 78,
		PS4_LeftTrigger_Pull = 79,
		PS4_LeftTrigger_Click = 80,
		PS4_RightTrigger_Pull = 81,
		PS4_RightTrigger_Click = 82,
		PS4_LeftStick_Move = 83,
		PS4_LeftStick_Click = 84,
		PS4_LeftStick_DPadNorth = 85,
		PS4_LeftStick_DPadSouth = 86,
		PS4_LeftStick_DPadWest = 87,
		PS4_LeftStick_DPadEast = 88,
		PS4_RightStick_Move = 89,
		PS4_RightStick_Click = 90,
		PS4_RightStick_DPadNorth = 91,
		PS4_RightStick_DPadSouth = 92,
		PS4_RightStick_DPadWest = 93,
		PS4_RightStick_DPadEast = 94,
		PS4_DPad_North = 95,
		PS4_DPad_South = 96,
		PS4_DPad_West = 97,
		PS4_DPad_East = 98,
		PS4_Gyro_Move = 99,
		PS4_Gyro_Pitch = 100,
		PS4_Gyro_Yaw = 101,
		PS4_Gyro_Roll = 102,
		PS4_DPad_Move = 103,
		PS4_Reserved1 = 104,
		PS4_Reserved2 = 105,
		PS4_Reserved3 = 106,
		PS4_Reserved4 = 107,
		PS4_Reserved5 = 108,
		PS4_Reserved6 = 109,
		PS4_Reserved7 = 110,
		PS4_Reserved8 = 111,
		PS4_Reserved9 = 112,
		PS4_Reserved10 = 113,
		XBoxOne_A = 114,
		XBoxOne_B = 115,
		XBoxOne_X = 116,
		XBoxOne_Y = 117,
		XBoxOne_LeftBumper = 118,
		XBoxOne_RightBumper = 119,
		XBoxOne_Menu = 120,
		XBoxOne_View = 121,
		XBoxOne_LeftTrigger_Pull = 122,
		XBoxOne_LeftTrigger_Click = 123,
		XBoxOne_RightTrigger_Pull = 124,
		XBoxOne_RightTrigger_Click = 125,
		XBoxOne_LeftStick_Move = 126,
		XBoxOne_LeftStick_Click = 127,
		XBoxOne_LeftStick_DPadNorth = 128,
		XBoxOne_LeftStick_DPadSouth = 129,
		XBoxOne_LeftStick_DPadWest = 130,
		XBoxOne_LeftStick_DPadEast = 131,
		XBoxOne_RightStick_Move = 132,
		XBoxOne_RightStick_Click = 133,
		XBoxOne_RightStick_DPadNorth = 134,
		XBoxOne_RightStick_DPadSouth = 135,
		XBoxOne_RightStick_DPadWest = 136,
		XBoxOne_RightStick_DPadEast = 137,
		XBoxOne_DPad_North = 138,
		XBoxOne_DPad_South = 139,
		XBoxOne_DPad_West = 140,
		XBoxOne_DPad_East = 141,
		XBoxOne_DPad_Move = 142,
		XBoxOne_Reserved1 = 143,
		XBoxOne_Reserved2 = 144,
		XBoxOne_Reserved3 = 145,
		XBoxOne_Reserved4 = 146,
		XBoxOne_Reserved5 = 147,
		XBoxOne_Reserved6 = 148,
		XBoxOne_Reserved7 = 149,
		XBoxOne_Reserved8 = 150,
		XBoxOne_Reserved9 = 151,
		XBoxOne_Reserved10 = 152,
		XBox360_A = 153,
		XBox360_B = 154,
		XBox360_X = 155,
		XBox360_Y = 156,
		XBox360_LeftBumper = 157,
		XBox360_RightBumper = 158,
		XBox360_Start = 159,
		XBox360_Back = 160,
		XBox360_LeftTrigger_Pull = 161,
		XBox360_LeftTrigger_Click = 162,
		XBox360_RightTrigger_Pull = 163,
		XBox360_RightTrigger_Click = 164,
		XBox360_LeftStick_Move = 165,
		XBox360_LeftStick_Click = 166,
		XBox360_LeftStick_DPadNorth = 167,
		XBox360_LeftStick_DPadSouth = 168,
		XBox360_LeftStick_DPadWest = 169,
		XBox360_LeftStick_DPadEast = 170,
		XBox360_RightStick_Move = 171,
		XBox360_RightStick_Click = 172,
		XBox360_RightStick_DPadNorth = 173,
		XBox360_RightStick_DPadSouth = 174,
		XBox360_RightStick_DPadWest = 175,
		XBox360_RightStick_DPadEast = 176,
		XBox360_DPad_North = 177,
		XBox360_DPad_South = 178,
		XBox360_DPad_West = 179,
		XBox360_DPad_East = 180,
		XBox360_DPad_Move = 181,
		XBox360_Reserved1 = 182,
		XBox360_Reserved2 = 183,
		XBox360_Reserved3 = 184,
		XBox360_Reserved4 = 185,
		XBox360_Reserved5 = 186,
		XBox360_Reserved6 = 187,
		XBox360_Reserved7 = 188,
		XBox360_Reserved8 = 189,
		XBox360_Reserved9 = 190,
		XBox360_Reserved10 = 191,
		Switch_A = 192,
		Switch_B = 193,
		Switch_X = 194,
		Switch_Y = 195,
		Switch_LeftBumper = 196,
		Switch_RightBumper = 197,
		Switch_Plus = 198,
		Switch_Minus = 199,
		Switch_Capture = 200,
		Switch_LeftTrigger_Pull = 201,
		Switch_LeftTrigger_Click = 202,
		Switch_RightTrigger_Pull = 203,
		Switch_RightTrigger_Click = 204,
		Switch_LeftStick_Move = 205,
		Switch_LeftStick_Click = 206,
		Switch_LeftStick_DPadNorth = 207,
		Switch_LeftStick_DPadSouth = 208,
		Switch_LeftStick_DPadWest = 209,
		Switch_LeftStick_DPadEast = 210,
		Switch_RightStick_Move = 211,
		Switch_RightStick_Click = 212,
		Switch_RightStick_DPadNorth = 213,
		Switch_RightStick_DPadSouth = 214,
		Switch_RightStick_DPadWest = 215,
		Switch_RightStick_DPadEast = 216,
		Switch_DPad_North = 217,
		Switch_DPad_South = 218,
		Switch_DPad_West = 219,
		Switch_DPad_East = 220,
		Switch_ProGyro_Move = 221,
		Switch_ProGyro_Pitch = 222,
		Switch_ProGyro_Yaw = 223,
		Switch_ProGyro_Roll = 224,
		Switch_DPad_Move = 225,
		Switch_Reserved1 = 226,
		Switch_Reserved2 = 227,
		Switch_Reserved3 = 228,
		Switch_Reserved4 = 229,
		Switch_Reserved5 = 230,
		Switch_Reserved6 = 231,
		Switch_Reserved7 = 232,
		Switch_Reserved8 = 233,
		Switch_Reserved9 = 234,
		Switch_Reserved10 = 235,
		Switch_RightGyro_Move = 236,
		Switch_RightGyro_Pitch = 237,
		Switch_RightGyro_Yaw = 238,
		Switch_RightGyro_Roll = 239,
		Switch_LeftGyro_Move = 240,
		Switch_LeftGyro_Pitch = 241,
		Switch_LeftGyro_Yaw = 242,
		Switch_LeftGyro_Roll = 243,
		Switch_LeftGrip_Lower = 244,
		Switch_LeftGrip_Upper = 245,
		Switch_RightGrip_Lower = 246,
		Switch_RightGrip_Upper = 247,
		Switch_Reserved11 = 248,
		Switch_Reserved12 = 249,
		Switch_Reserved13 = 250,
		Switch_Reserved14 = 251,
		Switch_Reserved15 = 252,
		Switch_Reserved16 = 253,
		Switch_Reserved17 = 254,
		Switch_Reserved18 = 255,
		Switch_Reserved19 = 256,
		Switch_Reserved20 = 257,
		Count = 258,
		MaximumPossibleValue = 32767
	}
	internal enum XboxOrigin
	{
		A,
		B,
		X,
		Y,
		LeftBumper,
		RightBumper,
		Menu,
		View,
		LeftTrigger_Pull,
		LeftTrigger_Click,
		RightTrigger_Pull,
		RightTrigger_Click,
		LeftStick_Move,
		LeftStick_Click,
		LeftStick_DPadNorth,
		LeftStick_DPadSouth,
		LeftStick_DPadWest,
		LeftStick_DPadEast,
		RightStick_Move,
		RightStick_Click,
		RightStick_DPadNorth,
		RightStick_DPadSouth,
		RightStick_DPadWest,
		RightStick_DPadEast,
		DPad_North,
		DPad_South,
		DPad_West,
		DPad_East,
		Count
	}
	internal enum SteamControllerPad
	{
		Left,
		Right
	}
	public enum InputType
	{
		Unknown = 0,
		SteamController = 1,
		XBox360Controller = 2,
		XBoxOneController = 3,
		GenericGamepad = 4,
		PS4Controller = 5,
		AppleMFiController = 6,
		AndroidController = 7,
		SwitchJoyConPair = 8,
		SwitchJoyConSingle = 9,
		SwitchProController = 10,
		MobileTouch = 11,
		PS3Controller = 12,
		Count = 13,
		MaximumPossibleValue = 255
	}
	internal enum SteamInputLEDFlag
	{
		SetColor,
		RestoreUserDefault
	}
	internal enum ControllerActionOrigin
	{
		None = 0,
		A = 1,
		B = 2,
		X = 3,
		Y = 4,
		LeftBumper = 5,
		RightBumper = 6,
		LeftGrip = 7,
		RightGrip = 8,
		Start = 9,
		Back = 10,
		LeftPad_Touch = 11,
		LeftPad_Swipe = 12,
		LeftPad_Click = 13,
		LeftPad_DPadNorth = 14,
		LeftPad_DPadSouth = 15,
		LeftPad_DPadWest = 16,
		LeftPad_DPadEast = 17,
		RightPad_Touch = 18,
		RightPad_Swipe = 19,
		RightPad_Click = 20,
		RightPad_DPadNorth = 21,
		RightPad_DPadSouth = 22,
		RightPad_DPadWest = 23,
		RightPad_DPadEast = 24,
		LeftTrigger_Pull = 25,
		LeftTrigger_Click = 26,
		RightTrigger_Pull = 27,
		RightTrigger_Click = 28,
		LeftStick_Move = 29,
		LeftStick_Click = 30,
		LeftStick_DPadNorth = 31,
		LeftStick_DPadSouth = 32,
		LeftStick_DPadWest = 33,
		LeftStick_DPadEast = 34,
		Gyro_Move = 35,
		Gyro_Pitch = 36,
		Gyro_Yaw = 37,
		Gyro_Roll = 38,
		PS4_X = 39,
		PS4_Circle = 40,
		PS4_Triangle = 41,
		PS4_Square = 42,
		PS4_LeftBumper = 43,
		PS4_RightBumper = 44,
		PS4_Options = 45,
		PS4_Share = 46,
		PS4_LeftPad_Touch = 47,
		PS4_LeftPad_Swipe = 48,
		PS4_LeftPad_Click = 49,
		PS4_LeftPad_DPadNorth = 50,
		PS4_LeftPad_DPadSouth = 51,
		PS4_LeftPad_DPadWest = 52,
		PS4_LeftPad_DPadEast = 53,
		PS4_RightPad_Touch = 54,
		PS4_RightPad_Swipe = 55,
		PS4_RightPad_Click = 56,
		PS4_RightPad_DPadNorth = 57,
		PS4_RightPad_DPadSouth = 58,
		PS4_RightPad_DPadWest = 59,
		PS4_RightPad_DPadEast = 60,
		PS4_CenterPad_Touch = 61,
		PS4_CenterPad_Swipe = 62,
		PS4_CenterPad_Click = 63,
		PS4_CenterPad_DPadNorth = 64,
		PS4_CenterPad_DPadSouth = 65,
		PS4_CenterPad_DPadWest = 66,
		PS4_CenterPad_DPadEast = 67,
		PS4_LeftTrigger_Pull = 68,
		PS4_LeftTrigger_Click = 69,
		PS4_RightTrigger_Pull = 70,
		PS4_RightTrigger_Click = 71,
		PS4_LeftStick_Move = 72,
		PS4_LeftStick_Click = 73,
		PS4_LeftStick_DPadNorth = 74,
		PS4_LeftStick_DPadSouth = 75,
		PS4_LeftStick_DPadWest = 76,
		PS4_LeftStick_DPadEast = 77,
		PS4_RightStick_Move = 78,
		PS4_RightStick_Click = 79,
		PS4_RightStick_DPadNorth = 80,
		PS4_RightStick_DPadSouth = 81,
		PS4_RightStick_DPadWest = 82,
		PS4_RightStick_DPadEast = 83,
		PS4_DPad_North = 84,
		PS4_DPad_South = 85,
		PS4_DPad_West = 86,
		PS4_DPad_East = 87,
		PS4_Gyro_Move = 88,
		PS4_Gyro_Pitch = 89,
		PS4_Gyro_Yaw = 90,
		PS4_Gyro_Roll = 91,
		XBoxOne_A = 92,
		XBoxOne_B = 93,
		XBoxOne_X = 94,
		XBoxOne_Y = 95,
		XBoxOne_LeftBumper = 96,
		XBoxOne_RightBumper = 97,
		XBoxOne_Menu = 98,
		XBoxOne_View = 99,
		XBoxOne_LeftTrigger_Pull = 100,
		XBoxOne_LeftTrigger_Click = 101,
		XBoxOne_RightTrigger_Pull = 102,
		XBoxOne_RightTrigger_Click = 103,
		XBoxOne_LeftStick_Move = 104,
		XBoxOne_LeftStick_Click = 105,
		XBoxOne_LeftStick_DPadNorth = 106,
		XBoxOne_LeftStick_DPadSouth = 107,
		XBoxOne_LeftStick_DPadWest = 108,
		XBoxOne_LeftStick_DPadEast = 109,
		XBoxOne_RightStick_Move = 110,
		XBoxOne_RightStick_Click = 111,
		XBoxOne_RightStick_DPadNorth = 112,
		XBoxOne_RightStick_DPadSouth = 113,
		XBoxOne_RightStick_DPadWest = 114,
		XBoxOne_RightStick_DPadEast = 115,
		XBoxOne_DPad_North = 116,
		XBoxOne_DPad_South = 117,
		XBoxOne_DPad_West = 118,
		XBoxOne_DPad_East = 119,
		XBox360_A = 120,
		XBox360_B = 121,
		XBox360_X = 122,
		XBox360_Y = 123,
		XBox360_LeftBumper = 124,
		XBox360_RightBumper = 125,
		XBox360_Start = 126,
		XBox360_Back = 127,
		XBox360_LeftTrigger_Pull = 128,
		XBox360_LeftTrigger_Click = 129,
		XBox360_RightTrigger_Pull = 130,
		XBox360_RightTrigger_Click = 131,
		XBox360_LeftStick_Move = 132,
		XBox360_LeftStick_Click = 133,
		XBox360_LeftStick_DPadNorth = 134,
		XBox360_LeftStick_DPadSouth = 135,
		XBox360_LeftStick_DPadWest = 136,
		XBox360_LeftStick_DPadEast = 137,
		XBox360_RightStick_Move = 138,
		XBox360_RightStick_Click = 139,
		XBox360_RightStick_DPadNorth = 140,
		XBox360_RightStick_DPadSouth = 141,
		XBox360_RightStick_DPadWest = 142,
		XBox360_RightStick_DPadEast = 143,
		XBox360_DPad_North = 144,
		XBox360_DPad_South = 145,
		XBox360_DPad_West = 146,
		XBox360_DPad_East = 147,
		SteamV2_A = 148,
		SteamV2_B = 149,
		SteamV2_X = 150,
		SteamV2_Y = 151,
		SteamV2_LeftBumper = 152,
		SteamV2_RightBumper = 153,
		SteamV2_LeftGrip_Lower = 154,
		SteamV2_LeftGrip_Upper = 155,
		SteamV2_RightGrip_Lower = 156,
		SteamV2_RightGrip_Upper = 157,
		SteamV2_LeftBumper_Pressure = 158,
		SteamV2_RightBumper_Pressure = 159,
		SteamV2_LeftGrip_Pressure = 160,
		SteamV2_RightGrip_Pressure = 161,
		SteamV2_LeftGrip_Upper_Pressure = 162,
		SteamV2_RightGrip_Upper_Pressure = 163,
		SteamV2_Start = 164,
		SteamV2_Back = 165,
		SteamV2_LeftPad_Touch = 166,
		SteamV2_LeftPad_Swipe = 167,
		SteamV2_LeftPad_Click = 168,
		SteamV2_LeftPad_Pressure = 169,
		SteamV2_LeftPad_DPadNorth = 170,
		SteamV2_LeftPad_DPadSouth = 171,
		SteamV2_LeftPad_DPadWest = 172,
		SteamV2_LeftPad_DPadEast = 173,
		SteamV2_RightPad_Touch = 174,
		SteamV2_RightPad_Swipe = 175,
		SteamV2_RightPad_Click = 176,
		SteamV2_RightPad_Pressure = 177,
		SteamV2_RightPad_DPadNorth = 178,
		SteamV2_RightPad_DPadSouth = 179,
		SteamV2_RightPad_DPadWest = 180,
		SteamV2_RightPad_DPadEast = 181,
		SteamV2_LeftTrigger_Pull = 182,
		SteamV2_LeftTrigger_Click = 183,
		SteamV2_RightTrigger_Pull = 184,
		SteamV2_RightTrigger_Click = 185,
		SteamV2_LeftStick_Move = 186,
		SteamV2_LeftStick_Click = 187,
		SteamV2_LeftStick_DPadNorth = 188,
		SteamV2_LeftStick_DPadSouth = 189,
		SteamV2_LeftStick_DPadWest = 190,
		SteamV2_LeftStick_DPadEast = 191,
		SteamV2_Gyro_Move = 192,
		SteamV2_Gyro_Pitch = 193,
		SteamV2_Gyro_Yaw = 194,
		SteamV2_Gyro_Roll = 195,
		Switch_A = 196,
		Switch_B = 197,
		Switch_X = 198,
		Switch_Y = 199,
		Switch_LeftBumper = 200,
		Switch_RightBumper = 201,
		Switch_Plus = 202,
		Switch_Minus = 203,
		Switch_Capture = 204,
		Switch_LeftTrigger_Pull = 205,
		Switch_LeftTrigger_Click = 206,
		Switch_RightTrigger_Pull = 207,
		Switch_RightTrigger_Click = 208,
		Switch_LeftStick_Move = 209,
		Switch_LeftStick_Click = 210,
		Switch_LeftStick_DPadNorth = 211,
		Switch_LeftStick_DPadSouth = 212,
		Switch_LeftStick_DPadWest = 213,
		Switch_LeftStick_DPadEast = 214,
		Switch_RightStick_Move = 215,
		Switch_RightStick_Click = 216,
		Switch_RightStick_DPadNorth = 217,
		Switch_RightStick_DPadSouth = 218,
		Switch_RightStick_DPadWest = 219,
		Switch_RightStick_DPadEast = 220,
		Switch_DPad_North = 221,
		Switch_DPad_South = 222,
		Switch_DPad_West = 223,
		Switch_DPad_East = 224,
		Switch_ProGyro_Move = 225,
		Switch_ProGyro_Pitch = 226,
		Switch_ProGyro_Yaw = 227,
		Switch_ProGyro_Roll = 228,
		Switch_RightGyro_Move = 229,
		Switch_RightGyro_Pitch = 230,
		Switch_RightGyro_Yaw = 231,
		Switch_RightGyro_Roll = 232,
		Switch_LeftGyro_Move = 233,
		Switch_LeftGyro_Pitch = 234,
		Switch_LeftGyro_Yaw = 235,
		Switch_LeftGyro_Roll = 236,
		Switch_LeftGrip_Lower = 237,
		Switch_LeftGrip_Upper = 238,
		Switch_RightGrip_Lower = 239,
		Switch_RightGrip_Upper = 240,
		PS4_DPad_Move = 241,
		XBoxOne_DPad_Move = 242,
		XBox360_DPad_Move = 243,
		Switch_DPad_Move = 244,
		Count = 245,
		MaximumPossibleValue = 32767
	}
	internal enum SteamControllerLEDFlag
	{
		SetColor,
		RestoreUserDefault
	}
	public enum UgcType
	{
		Items = 0,
		Items_Mtx = 1,
		Items_ReadyToUse = 2,
		Collections = 3,
		Artwork = 4,
		Videos = 5,
		Screenshots = 6,
		AllGuides = 7,
		WebGuides = 8,
		IntegratedGuides = 9,
		UsableInGame = 10,
		ControllerBindings = 11,
		GameManagedItems = 12,
		All = -1
	}
	internal enum UserUGCList
	{
		Published,
		VotedOn,
		VotedUp,
		VotedDown,
		WillVoteLater,
		Favorited,
		Subscribed,
		UsedOrPlayed,
		Followed
	}
	internal enum UserUGCListSortOrder
	{
		CreationOrderDesc,
		CreationOrderAsc,
		TitleAsc,
		LastUpdatedDesc,
		SubscriptionDateDesc,
		VoteScoreDesc,
		ForModeration
	}
	internal enum UGCQuery
	{
		RankedByVote,
		RankedByPublicationDate,
		AcceptedForGameRankedByAcceptanceDate,
		RankedByTrend,
		FavoritedByFriendsRankedByPublicationDate,
		CreatedByFriendsRankedByPublicationDate,
		RankedByNumTimesReported,
		CreatedByFollowedUsersRankedByPublicationDate,
		NotYetRated,
		RankedByTotalVotesAsc,
		RankedByVotesUp,
		RankedByTextSearch,
		RankedByTotalUniqueSubscriptions,
		RankedByPlaytimeTrend,
		RankedByTotalPlaytime,
		RankedByAveragePlaytimeTrend,
		RankedByLifetimeAveragePlaytime,
		RankedByPlaytimeSessionsTrend,
		RankedByLifetimePlaytimeSessions
	}
	internal enum ItemUpdateStatus
	{
		Invalid,
		PreparingConfig,
		PreparingContent,
		UploadingContent,
		UploadingPreviewFile,
		CommittingChanges
	}
	internal enum ItemState
	{
		None = 0,
		Subscribed = 1,
		LegacyItem = 2,
		Installed = 4,
		NeedsUpdate = 8,
		Downloading = 0x10,
		DownloadPending = 0x20
	}
	internal enum ItemStatistic
	{
		NumSubscriptions,
		NumFavorites,
		NumFollowers,
		NumUniqueSubscriptions,
		NumUniqueFavorites,
		NumUniqueFollowers,
		NumUniqueWebsiteViews,
		ReportScore,
		NumSecondsPlayed,
		NumPlaytimeSessions,
		NumComments,
		NumSecondsPlayedDuringTimePeriod,
		NumPlaytimeSessionsDuringTimePeriod
	}
	internal enum ItemPreviewType
	{
		Image = 0,
		YouTubeVideo = 1,
		Sketchfab = 2,
		EnvironmentMap_HorizontalCross = 3,
		EnvironmentMap_LatLong = 4,
		ReservedMax = 255
	}
	internal enum SteamItemFlags
	{
		NoTrade = 1,
		Removed = 0x100,
		Consumed = 0x200
	}
	internal enum SteamTVRegionBehavior
	{
		Invalid = -1,
		Hover,
		ClickPopup,
		ClickSurroundingRegion
	}
	public enum ParentalFeature
	{
		Invalid,
		Store,
		Community,
		Profile,
		Friends,
		News,
		Trading,
		Settings,
		Console,
		Browser,
		ParentalSetup,
		Library,
		Test,
		SiteLicense,
		Max
	}
	public enum SteamDeviceFormFactor
	{
		Unknown,
		Phone,
		Tablet,
		Computer,
		TV
	}
	public enum SteamNetworkingAvailability
	{
		CannotTry = -102,
		Failed = -101,
		Previously = -100,
		Retrying = -10,
		NeverTried = 1,
		Waiting = 2,
		Attempting = 3,
		Current = 100,
		Unknown = 0,
		Force32bit = int.MaxValue
	}
	internal enum NetIdentityType
	{
		Invalid = 0,
		SteamID = 16,
		XboxPairwiseID = 17,
		IPAddress = 1,
		GenericString = 2,
		GenericBytes = 3,
		UnknownType = 4,
		Force32bit = int.MaxValue
	}
	public enum ConnectionState
	{
		None = 0,
		Connecting = 1,
		FindingRoute = 2,
		Connected = 3,
		ClosedByPeer = 4,
		ProblemDetectedLocally = 5,
		FinWait = -1,
		Linger = -2,
		Dead = -3
	}
	public enum NetConnectionEnd
	{
		Invalid = 0,
		App_Min = 1000,
		App_Generic = 1000,
		App_Max = 1999,
		AppException_Min = 2000,
		AppException_Generic = 2000,
		AppException_Max = 2999,
		Local_Min = 3000,
		Local_OfflineMode = 3001,
		Local_ManyRelayConnectivity = 3002,
		Local_HostedServerPrimaryRelay = 3003,
		Local_NetworkConfig = 3004,
		Local_Rights = 3005,
		Local_Max = 3999,
		Remote_Min = 4000,
		Remote_Timeout = 4001,
		Remote_BadCrypt = 4002,
		Remote_BadCert = 4003,
		Remote_NotLoggedIn = 4004,
		Remote_NotRunningApp = 4005,
		Remote_BadProtocolVersion = 4006,
		Remote_Max = 4999,
		Misc_Min = 5000,
		Misc_Generic = 5001,
		Misc_InternalError = 5002,
		Misc_Timeout = 5003,
		Misc_RelayConnectivity = 5004,
		Misc_SteamConnectivity = 5005,
		Misc_NoRelaySessionsToClient = 5006,
		Misc_Max = 5999
	}
	internal enum NetConfigScope
	{
		Global = 1,
		SocketsInterface,
		ListenSocket,
		Connection
	}
	internal enum NetConfigType
	{
		Int32 = 1,
		Int64,
		Float,
		String,
		FunctionPtr
	}
	internal enum NetConfig
	{
		Invalid = 0,
		FakePacketLoss_Send = 2,
		FakePacketLoss_Recv = 3,
		FakePacketLag_Send = 4,
		FakePacketLag_Recv = 5,
		FakePacketReorder_Send = 6,
		FakePacketReorder_Recv = 7,
		FakePacketReorder_Time = 8,
		FakePacketDup_Send = 26,
		FakePacketDup_Recv = 27,
		FakePacketDup_TimeMax = 28,
		TimeoutInitial = 24,
		TimeoutConnected = 25,
		SendBufferSize = 9,
		SendRateMin = 10,
		SendRateMax = 11,
		NagleTime = 12,
		IP_AllowWithoutAuth = 23,
		MTU_PacketSize = 32,
		MTU_DataSize = 33,
		Unencrypted = 34,
		EnumerateDevVars = 35,
		SDRClient_ConsecutitivePingTimeoutsFailInitial = 19,
		SDRClient_ConsecutitivePingTimeoutsFail = 20,
		SDRClient_MinPingsBeforePingAccurate = 21,
		SDRClient_SingleSocket = 22,
		SDRClient_ForceRelayCluster = 29,
		SDRClient_DebugTicketAddress = 30,
		SDRClient_ForceProxyAddr = 31,
		SDRClient_FakeClusterPing = 36,
		LogLevel_AckRTT = 13,
		LogLevel_PacketDecode = 14,
		LogLevel_Message = 15,
		LogLevel_PacketGaps = 16,
		LogLevel_P2PRendezvous = 17,
		LogLevel_SDRRelayPings = 18
	}
	internal enum NetConfigResult
	{
		BadValue = -1,
		BadScopeObj = -2,
		BufferTooSmall = -3,
		OK = 1,
		OKInherited = 2
	}
	public enum NetDebugOutput
	{
		None,
		Bug,
		Error,
		Important,
		Warning,
		Msg,
		Verbose,
		Debug,
		Everything
	}
	internal enum ServerMode
	{
		Invalid,
		NoAuthentication,
		Authentication,
		AuthenticationAndSecure
	}
	public class ConnectionManager
	{
		public Connection Connection;

		public bool Connected;

		public bool Connecting = true;

		public IConnectionManager Interface { get; set; }

		public ConnectionInfo ConnectionInfo { get; internal set; }

		public string ConnectionName
		{
			get
			{
				return Connection.ConnectionName;
			}
			set
			{
				Connection.ConnectionName = value;
			}
		}

		public long UserData
		{
			get
			{
				return Connection.UserData;
			}
			set
			{
				Connection.UserData = value;
			}
		}

		public void Close()
		{
			Connection.Close();
		}

		public override string ToString()
		{
			return Connection.ToString();
		}

		public virtual void OnConnectionChanged(ConnectionInfo info)
		{
			ConnectionInfo = info;
			switch (info.State)
			{
			case ConnectionState.Connecting:
				OnConnecting(info);
				break;
			case ConnectionState.Connected:
				OnConnected(info);
				break;
			case ConnectionState.None:
			case ConnectionState.ClosedByPeer:
			case ConnectionState.ProblemDetectedLocally:
				OnDisconnected(info);
				break;
			case ConnectionState.FindingRoute:
				break;
			}
		}

		public virtual void OnConnecting(ConnectionInfo info)
		{
			Interface?.OnConnecting(info);
			Connecting = true;
		}

		public virtual void OnConnected(ConnectionInfo info)
		{
			Interface?.OnConnected(info);
			Connected = true;
			Connecting = false;
		}

		public virtual void OnDisconnected(ConnectionInfo info)
		{
			Interface?.OnDisconnected(info);
			Connected = false;
			Connecting = false;
		}

		public void Receive(int bufferSize = 32)
		{
			int num = 0;
			IntPtr intPtr = Marshal.AllocHGlobal(IntPtr.Size * bufferSize);
			try
			{
				num = SteamNetworkingSockets.Internal.ReceiveMessagesOnConnection(Connection, intPtr, bufferSize);
				for (int i = 0; i < num; i++)
				{
					ReceiveMessage(Marshal.ReadIntPtr(intPtr, i * IntPtr.Size));
				}
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
			if (num == bufferSize)
			{
				Receive(bufferSize);
			}
		}

		internal unsafe void ReceiveMessage(IntPtr msgPtr)
		{
			NetMsg netMsg = Marshal.PtrToStructure<NetMsg>(msgPtr);
			try
			{
				OnMessage(netMsg.DataPtr, netMsg.DataSize, netMsg.RecvTime, netMsg.MessageNumber, netMsg.Channel);
			}
			finally
			{
				NetMsg.InternalRelease((NetMsg*)(void*)msgPtr);
			}
		}

		public virtual void OnMessage(IntPtr data, int size, long messageNum, long recvTime, int channel)
		{
			Interface?.OnMessage(data, size, messageNum, recvTime, channel);
		}
	}
	public interface IConnectionManager
	{
		void OnConnecting(ConnectionInfo info);

		void OnConnected(ConnectionInfo info);

		void OnDisconnected(ConnectionInfo info);

		void OnMessage(IntPtr data, int size, long messageNum, long recvTime, int channel);
	}
	public interface ISocketManager
	{
		void OnConnecting(Connection connection, ConnectionInfo info);

		void OnConnected(Connection connection, ConnectionInfo info);

		void OnDisconnected(Connection connection, ConnectionInfo info);

		void OnMessage(Connection connection, NetIdentity identity, IntPtr data, int size, long messageNum, long recvTime, int channel);
	}
	public class SocketManager
	{
		public List<Connection> Connecting = new List<Connection>();

		public List<Connection> Connected = new List<Connection>();

		internal HSteamNetPollGroup pollGroup;

		public ISocketManager Interface { get; set; }

		public Steamworks.Data.Socket Socket { get; internal set; }

		public override string ToString()
		{
			return Socket.ToString();
		}

		internal void Initialize()
		{
			pollGroup = SteamNetworkingSockets.Internal.CreatePollGroup();
		}

		public bool Close()
		{
			if (SteamNetworkingSockets.Internal.IsValid)
			{
				SteamNetworkingSockets.Internal.DestroyPollGroup(pollGroup);
				Socket.Close();
			}
			pollGroup = 0u;
			Socket = 0u;
			return true;
		}

		public virtual void OnConnectionChanged(Connection connection, ConnectionInfo info)
		{
			switch (info.State)
			{
			case ConnectionState.Connecting:
				if (!Connecting.Contains(connection))
				{
					Connecting.Add(connection);
					OnConnecting(connection, info);
				}
				break;
			case ConnectionState.Connected:
				if (!Connected.Contains(connection))
				{
					Connecting.Remove(connection);
					Connected.Add(connection);
					OnConnected(connection, info);
				}
				break;
			case ConnectionState.None:
			case ConnectionState.ClosedByPeer:
			case ConnectionState.ProblemDetectedLocally:
				if (Connecting.Contains(connection) || Connected.Contains(connection))
				{
					OnDisconnected(connection, info);
				}
				break;
			case ConnectionState.FindingRoute:
				break;
			}
		}

		public virtual void OnConnecting(Connection connection, ConnectionInfo info)
		{
			if (Interface != null)
			{
				Interface.OnConnecting(connection, info);
			}
			else
			{
				connection.Accept();
			}
		}

		public virtual void OnConnected(Connection connection, ConnectionInfo info)
		{
			SteamNetworkingSockets.Internal.SetConnectionPollGroup(connection, pollGroup);
			Interface?.OnConnected(connection, info);
		}

		public virtual void OnDisconnected(Connection connection, ConnectionInfo info)
		{
			SteamNetworkingSockets.Internal.SetConnectionPollGroup(connection, 0u);
			connection.Close();
			Connecting.Remove(connection);
			Connected.Remove(connection);
			Interface?.OnDisconnected(connection, info);
		}

		public void Receive(int bufferSize = 32)
		{
			int num = 0;
			IntPtr intPtr = Marshal.AllocHGlobal(IntPtr.Size * bufferSize);
			try
			{
				num = SteamNetworkingSockets.Internal.ReceiveMessagesOnPollGroup(pollGroup, intPtr, bufferSize);
				for (int i = 0; i < num; i++)
				{
					ReceiveMessage(Marshal.ReadIntPtr(intPtr, i * IntPtr.Size));
				}
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
			if (num == bufferSize)
			{
				Receive(bufferSize);
			}
		}

		internal unsafe void ReceiveMessage(IntPtr msgPtr)
		{
			NetMsg netMsg = Marshal.PtrToStructure<NetMsg>(msgPtr);
			try
			{
				OnMessage(netMsg.Connection, netMsg.Identity, netMsg.DataPtr, netMsg.DataSize, netMsg.RecvTime, netMsg.MessageNumber, netMsg.Channel);
			}
			finally
			{
				NetMsg.InternalRelease((NetMsg*)(void*)msgPtr);
			}
		}

		public virtual void OnMessage(Connection connection, NetIdentity identity, IntPtr data, int size, long messageNum, long recvTime, int channel)
		{
			Interface?.OnMessage(connection, identity, data, size, messageNum, recvTime, channel);
		}
	}
	public class SteamApps : SteamSharedClass<SteamApps>
	{
		[CompilerGenerated]
		private sealed class <DlcInformation>d__29 : IEnumerable<DlcInformation>, IEnumerable, IEnumerator<DlcInformation>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private DlcInformation <>2__current;

			private int <>l__initialThreadId;

			private AppId <appid>5__2;

			private bool <available>5__3;

			private int <i>5__4;

			DlcInformation IEnumerator<DlcInformation>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DlcInformation>d__29(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_00a1;
				}
				<>1__state = -1;
				<appid>5__2 = default(AppId);
				<available>5__3 = false;
				<i>5__4 = 0;
				goto IL_00b1;
				IL_00a1:
				<i>5__4++;
				goto IL_00b1;
				IL_00b1:
				if (<i>5__4 < Internal.GetDLCCount())
				{
					if (Internal.BGetDLCDataByIndex(<i>5__4, ref <appid>5__2, ref <available>5__3, out var pchName))
					{
						<>2__current = new DlcInformation
						{
							AppId = <appid>5__2.Value,
							Name = pchName,
							Available = <available>5__3
						};
						<>1__state = 1;
						return true;
					}
					goto IL_00a1;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<DlcInformation> IEnumerable<DlcInformation>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <DlcInformation>d__29(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<DlcInformation>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <InstalledDepots>d__35 : IEnumerable<DepotId>, IEnumerable, IEnumerator<DepotId>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private DepotId <>2__current;

			private int <>l__initialThreadId;

			private AppId appid;

			public AppId <>3__appid;

			private DepotId_t[] <depots>5__2;

			private uint <count>5__3;

			private int <i>5__4;

			DepotId IEnumerator<DepotId>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <InstalledDepots>d__35(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<depots>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((uint)appid == 0)
					{
						appid = SteamClient.AppId;
					}
					<depots>5__2 = new DepotId_t[32];
					<count>5__3 = Internal.GetInstalledDepots(appid.Value, <depots>5__2, (uint)<depots>5__2.Length);
					<i>5__4 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__4++;
					break;
				}
				if (<i>5__4 < <count>5__3)
				{
					<>2__current = new DepotId
					{
						Value = <depots>5__2[<i>5__4].Value
					};
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<DepotId> IEnumerable<DepotId>.GetEnumerator()
			{
				<InstalledDepots>d__35 <InstalledDepots>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<InstalledDepots>d__ = this;
				}
				else
				{
					<InstalledDepots>d__ = new <InstalledDepots>d__35(0);
				}
				<InstalledDepots>d__.appid = <>3__appid;
				return <InstalledDepots>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<DepotId>)this).GetEnumerator();
			}
		}

		internal static ISteamApps Internal => SteamSharedClass<SteamApps>.Interface as ISteamApps;

		public static bool IsSubscribed => Internal.BIsSubscribed();

		public static bool IsSubscribedFromFamilySharing => Internal.BIsSubscribedFromFamilySharing();

		public static bool IsLowVoilence => Internal.BIsLowViolence();

		public static bool IsCybercafe => Internal.BIsCybercafe();

		public static bool IsVACBanned => Internal.BIsVACBanned();

		public static string GameLanguage => Internal.GetCurrentGameLanguage();

		public static string[] AvailableLanguages => Internal.GetAvailableGameLanguages().Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);

		public static bool IsSubscribedFromFreeWeekend => Internal.BIsSubscribedFromFreeWeekend();

		public static string CurrentBetaName
		{
			get
			{
				if (!Internal.GetCurrentBetaName(out var pchName))
				{
					return null;
				}
				return pchName;
			}
		}

		public static SteamId AppOwner => Internal.GetAppOwner().Value;

		public static int BuildId => Internal.GetAppBuildId();

		public static string CommandLine
		{
			get
			{
				Internal.GetLaunchCommandLine(out var pszCommandLine);
				return pszCommandLine;
			}
		}

		public static event Action<AppId> OnDlcInstalled;

		public static event Action OnNewLaunchParameters;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamApps(server));
		}

		internal static void InstallEvents()
		{
			Dispatch.Install(delegate(DlcInstalled_t x)
			{
				SteamApps.OnDlcInstalled?.Invoke(x.AppID);
			});
			Dispatch.Install<NewUrlLaunchParameters_t>(delegate
			{
				SteamApps.OnNewLaunchParameters?.Invoke();
			});
		}

		public static bool IsSubscribedToApp(AppId appid)
		{
			return Internal.BIsSubscribedApp(appid.Value);
		}

		public static bool IsDlcInstalled(AppId appid)
		{
			return Internal.BIsDlcInstalled(appid.Value);
		}

		public static DateTime PurchaseTime(AppId appid = default(AppId))
		{
			if ((uint)appid == 0)
			{
				appid = SteamClient.AppId;
			}
			return Epoch.ToDateTime(Internal.GetEarliestPurchaseUnixTime(appid.Value));
		}

		[IteratorStateMachine(typeof(<DlcInformation>d__29))]
		public static IEnumerable<DlcInformation> DlcInformation()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DlcInformation>d__29(-2);
		}

		public static void InstallDlc(AppId appid)
		{
			Internal.InstallDLC(appid.Value);
		}

		public static void UninstallDlc(AppId appid)
		{
			Internal.UninstallDLC(appid.Value);
		}

		public static void MarkContentCorrupt(bool missingFilesOnly)
		{
			Internal.MarkContentCorrupt(missingFilesOnly);
		}

		[IteratorStateMachine(typeof(<InstalledDepots>d__35))]
		public static IEnumerable<DepotId> InstalledDepots(AppId appid = default(AppId))
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <InstalledDepots>d__35(-2)
			{
				<>3__appid = appid
			};
		}

		public static string AppInstallDir(AppId appid = default(AppId))
		{
			if ((uint)appid == 0)
			{
				appid = SteamClient.AppId;
			}
			if (Internal.GetAppInstallDir(appid.Value, out var pchFolder) == 0)
			{
				return null;
			}
			return pchFolder;
		}

		public static bool IsAppInstalled(AppId appid)
		{
			return Internal.BIsAppInstalled(appid.Value);
		}

		public static string GetLaunchParam(string param)
		{
			return Internal.GetLaunchQueryParam(param);
		}

		public static DownloadProgress DlcDownloadProgress(AppId appid)
		{
			ulong punBytesDownloaded = 0uL;
			ulong punBytesTotal = 0uL;
			if (!Internal.GetDlcDownloadProgress(appid.Value, ref punBytesDownloaded, ref punBytesTotal))
			{
				return default(DownloadProgress);
			}
			DownloadProgress result = default(DownloadProgress);
			result.BytesDownloaded = punBytesDownloaded;
			result.BytesTotal = punBytesTotal;
			result.Active = true;
			return result;
		}

		public static async Task<FileDetails?> GetFileDetailsAsync(string filename)
		{
			FileDetailsResult_t? fileDetailsResult_t = await Internal.GetFileDetails(filename);
			if (!fileDetailsResult_t.HasValue || fileDetailsResult_t.Value.Result != Result.OK)
			{
				return null;
			}
			FileDetails value = default(FileDetails);
			value.SizeInBytes = fileDetailsResult_t.Value.FileSize;
			value.Flags = fileDetailsResult_t.Value.Flags;
			value.Sha1 = string.Join("", fileDetailsResult_t.Value.FileSHA.Select((byte x) => x.ToString("x")));
			return value;
		}
	}
	public static class SteamClient
	{
		private static bool initialized;

		private static readonly List<SteamClass> openInterfaces = new List<SteamClass>();

		public static bool IsValid => initialized;

		public static bool IsLoggedOn => SteamUser.Internal.BLoggedOn();

		public static SteamId SteamId => SteamUser.Internal.GetSteamID();

		public static string Name => SteamFriends.Internal.GetPersonaName();

		public static FriendState State => SteamFriends.Internal.GetPersonaState();

		public static AppId AppId { get; internal set; }

		public static void Init(uint appid, bool asyncCallbacks = true)
		{
			if (initialized)
			{
				throw new Exception("Calling SteamClient.Init but is already initialized");
			}
			Environment.SetEnvironmentVariable("SteamAppId", appid.ToString());
			Environment.SetEnvironmentVariable("SteamGameId", appid.ToString());
			if (!SteamAPI.Init())
			{
				throw new Exception("SteamApi_Init returned false. Steam isn't running, couldn't find Steam, AppId is ureleased, Don't own AppId.");
			}
			AppId = appid;
			initialized = true;
			Dispatch.Init();
			Dispatch.ClientPipe = SteamAPI.GetHSteamPipe();
			AddInterface<SteamApps>();
			AddInterface<SteamFriends>();
			AddInterface<SteamInput>();
			AddInterface<SteamInventory>();
			AddInterface<SteamMatchmaking>();
			AddInterface<SteamMatchmakingServers>();
			AddInterface<SteamMusic>();
			AddInterface<SteamNetworking>();
			AddInterface<SteamNetworkingSockets>();
			AddInterface<SteamNetworkingUtils>();
			AddInterface<SteamParental>();
			AddInterface<SteamParties>();
			AddInterface<SteamRemoteStorage>();
			AddInterface<SteamScreenshots>();
			AddInterface<SteamUGC>();
			AddInterface<SteamUser>();
			AddInterface<SteamUserStats>();
			AddInterface<SteamUtils>();
			AddInterface<SteamVideo>();
			AddInterface<SteamRemotePlay>();
			if (asyncCallbacks)
			{
				Dispatch.LoopClientAsync();
			}
		}

		internal static void AddInterface<T>() where T : SteamClass, new()
		{
			T val = new T();
			val.InitializeInterface(server: false);
			openInterfaces.Add(val);
		}

		internal static void ShutdownInterfaces()
		{
			foreach (SteamClass openInterface in openInterfaces)
			{
				openInterface.DestroyInterface(server: false);
			}
			openInterfaces.Clear();
		}

		public static void Shutdown()
		{
			if (IsValid)
			{
				Cleanup();
				SteamAPI.Shutdown();
			}
		}

		internal static void Cleanup()
		{
			Dispatch.ShutdownClient();
			initialized = false;
			ShutdownInterfaces();
		}

		public static void RunCallbacks()
		{
			if (Dispatch.ClientPipe != 0)
			{
				Dispatch.Frame(Dispatch.ClientPipe);
			}
		}

		public static bool RestartAppIfNecessary(uint appid)
		{
			return SteamAPI.RestartAppIfNecessary(appid);
		}

		internal static void ValidCheck()
		{
			if (!IsValid)
			{
				throw new Exception("SteamClient isn't initialized");
			}
		}
	}
	public class SteamFriends : SteamClientClass<SteamFriends>
	{
		[CompilerGenerated]
		private sealed class <GetFriendsWithFlag>d__27 : IEnumerable<Friend>, IEnumerable, IEnumerator<Friend>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private Friend <>2__current;

			private int <>l__initialThreadId;

			private FriendFlags flag;

			public FriendFlags <>3__flag;

			private int <i>5__2;

			Friend IEnumerator<Friend>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetFriendsWithFlag>d__27(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < Internal.GetFriendCount((int)flag))
				{
					<>2__current = new Friend(Internal.GetFriendByIndex(<i>5__2, (int)flag));
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<Friend> IEnumerable<Friend>.GetEnumerator()
			{
				<GetFriendsWithFlag>d__27 <GetFriendsWithFlag>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetFriendsWithFlag>d__ = this;
				}
				else
				{
					<GetFriendsWithFlag>d__ = new <GetFriendsWithFlag>d__27(0);
				}
				<GetFriendsWithFlag>d__.flag = <>3__flag;
				return <GetFriendsWithFlag>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Friend>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GetFromSource>d__35 : IEnumerable<Friend>, IEnumerable, IEnumerator<Friend>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private Friend <>2__current;

			private int <>l__initialThreadId;

			private SteamId steamid;

			public SteamId <>3__steamid;

			private int <i>5__2;

			Friend IEnumerator<Friend>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetFromSource>d__35(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < Internal.GetFriendCountFromSource(steamid))
				{
					<>2__current = new Friend(Internal.GetFriendFromSourceByIndex(steamid, <i>5__2));
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<Friend> IEnumerable<Friend>.GetEnumerator()
			{
				<GetFromSource>d__35 <GetFromSource>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetFromSource>d__ = this;
				}
				else
				{
					<GetFromSource>d__ = new <GetFromSource>d__35(0);
				}
				<GetFromSource>d__.steamid = <>3__steamid;
				return <GetFromSource>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Friend>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GetPlayedWith>d__34 : IEnumerable<Friend>, IEnumerable, IEnumerator<Friend>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private Friend <>2__current;

			private int <>l__initialThreadId;

			private int <i>5__2;

			Friend IEnumerator<Friend>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetPlayedWith>d__34(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < Internal.GetCoplayFriendCount())
				{
					<>2__current = new Friend(Internal.GetCoplayFriend(<i>5__2));
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<Friend> IEnumerable<Friend>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetPlayedWith>d__34(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Friend>)this).GetEnumerator();
			}
		}

		private static Dictionary<string, string> richPresence;

		private static bool _listenForFriendsMessages;

		internal static ISteamFriends Internal => SteamClientClass<SteamFriends>.Interface as ISteamFriends;

		public static bool ListenForFriendsMessages
		{
			get
			{
				return _listenForFriendsMessages;
			}
			set
			{
				_listenForFriendsMessages = value;
				Internal.SetListenForFriendsMessages(value);
			}
		}

		public static event Action<Friend, string, string> OnChatMessage;

		public static event Action<Friend> OnPersonaStateChange;

		public static event Action<Friend, string> OnGameRichPresenceJoinRequested;

		public static event Action<bool> OnGameOverlayActivated;

		public static event Action<string, string> OnGameServerChangeRequested;

		public static event Action<Lobby, SteamId> OnGameLobbyJoinRequested;

		public static event Action<Friend> OnFriendRichPresenceUpdate;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamFriends(server));
			richPresence = new Dictionary<string, string>();
			InstallEvents();
		}

		internal void InstallEvents()
		{
			Dispatch.Install(delegate(PersonaStateChange_t x)
			{
				SteamFriends.OnPersonaStateChange?.Invoke(new Friend(x.SteamID));
			});
			Dispatch.Install(delegate(GameRichPresenceJoinRequested_t x)
			{
				SteamFriends.OnGameRichPresenceJoinRequested?.Invoke(new Friend(x.SteamIDFriend), x.ConnectUTF8());
			});
			Dispatch.Install<GameConnectedFriendChatMsg_t>(OnFriendChatMessage);
			Dispatch.Install(delegate(GameOverlayActivated_t x)
			{
				SteamFriends.OnGameOverlayActivated?.Invoke(x.Active != 0);
			});
			Dispatch.Install(delegate(GameServerChangeRequested_t x)
			{
				SteamFriends.OnGameServerChangeRequested?.Invoke(x.ServerUTF8(), x.PasswordUTF8());
			});
			Dispatch.Install(delegate(GameLobbyJoinRequested_t x)
			{
				SteamFriends.OnGameLobbyJoinRequested?.Invoke(new Lobby(x.SteamIDLobby), x.SteamIDFriend);
			});
			Dispatch.Install(delegate(FriendRichPresenceUpdate_t x)
			{
				SteamFriends.OnFriendRichPresenceUpdate?.Invoke(new Friend(x.SteamIDFriend));
			});
		}

		private unsafe static void OnFriendChatMessage(GameConnectedFriendChatMsg_t data)
		{
			if (SteamFriends.OnChatMessage == null)
			{
				return;
			}
			Friend arg = new Friend(data.SteamIDUser);
			byte[] array = Helpers.TakeBuffer(32768);
			ChatEntryType peChatEntryType = ChatEntryType.ChatMsg;
			fixed (byte* ptr = array)
			{
				int friendMessage = Internal.GetFriendMessage(data.SteamIDUser, data.MessageID, (IntPtr)ptr, array.Length, ref peChatEntryType);
				if (friendMessage == 0 && peChatEntryType == ChatEntryType.Invalid)
				{
					return;
				}
				string arg2 = peChatEntryType.ToString();
				string @string = Encoding.UTF8.GetString(array, 0, friendMessage);
				SteamFriends.OnChatMessage(arg, arg2, @string);
			}
		}

		[IteratorStateMachine(typeof(<GetFriendsWithFlag>d__27))]
		private static IEnumerable<Friend> GetFriendsWithFlag(FriendFlags flag)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetFriendsWithFlag>d__27(-2)
			{
				<>3__flag = flag
			};
		}

		public static IEnumerable<Friend> GetFriends()
		{
			return GetFriendsWithFlag(FriendFlags.Immediate);
		}

		public static IEnumerable<Friend> GetBlocked()
		{
			return GetFriendsWithFlag(FriendFlags.Blocked);
		}

		public static IEnumerable<Friend> GetFriendsRequested()
		{
			return GetFriendsWithFlag(FriendFlags.FriendshipRequested);
		}

		public static IEnumerable<Friend> GetFriendsClanMembers()
		{
			return GetFriendsWithFlag(FriendFlags.ClanMember);
		}

		public static IEnumerable<Friend> GetFriendsOnGameServer()
		{
			return GetFriendsWithFlag(FriendFlags.OnGameServer);
		}

		public static IEnumerable<Friend> GetFriendsRequestingFriendship()
		{
			return GetFriendsWithFlag(FriendFlags.RequestingFriendship);
		}

		[IteratorStateMachine(typeof(<GetPlayedWith>d__34))]
		public static IEnumerable<Friend> GetPlayedWith()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetPlayedWith>d__34(-2);
		}

		[IteratorStateMachine(typeof(<GetFromSource>d__35))]
		public static IEnumerable<Friend> GetFromSource(SteamId steamid)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetFromSource>d__35(-2)
			{
				<>3__steamid = steamid
			};
		}

		public static void OpenOverlay(string type)
		{
			Internal.ActivateGameOverlay(type);
		}

		public static void OpenUserOverlay(SteamId id, string type)
		{
			Internal.ActivateGameOverlayToUser(type, id);
		}

		public static void OpenStoreOverlay(AppId id)
		{
			Internal.ActivateGameOverlayToStore(id.Value, OverlayToStoreFlag.None);
		}

		public static void OpenWebOverlay(string url, bool modal = false)
		{
			Internal.ActivateGameOverlayToWebPage(url, modal ? ActivateGameOverlayToWebPageMode.Modal : ActivateGameOverlayToWebPageMode.Default);
		}

		public static void OpenGameInviteOverlay(SteamId lobby)
		{
			Internal.ActivateGameOverlayInviteDialog(lobby);
		}

		public static void SetPlayedWith(SteamId steamid)
		{
			Internal.SetPlayedWith(steamid);
		}

		public static bool RequestUserInformation(SteamId steamid, bool nameonly = true)
		{
			return Internal.RequestUserInformation(steamid, nameonly);
		}

		internal static async Task CacheUserInformationAsync(SteamId steamid, bool nameonly)
		{
			if (RequestUserInformation(steamid, nameonly))
			{
				await Task.Delay(100);
				while (RequestUserInformation(steamid, nameonly))
				{
					await Task.Delay(50);
				}
				await Task.Delay(500);
			}
		}

		public static async Task<Image?> GetSmallAvatarAsync(SteamId steamid)
		{
			await CacheUserInformationAsync(steamid, nameonly: false);
			return SteamUtils.GetImage(Internal.GetSmallFriendAvatar(steamid));
		}

		public static async Task<Image?> GetMediumAvatarAsync(SteamId steamid)
		{
			await CacheUserInformationAsync(steamid, nameonly: false);
			return SteamUtils.GetImage(Internal.GetMediumFriendAvatar(steamid));
		}

		public static async Task<Image?> GetLargeAvatarAsync(SteamId steamid)
		{
			await CacheUserInformationAsync(steamid, nameonly: false);
			int largeFriendAvatar;
			for (largeFriendAvatar = Internal.GetLargeFriendAvatar(steamid); largeFriendAvatar == -1; largeFriendAvatar = Internal.GetLargeFriendAvatar(steamid))
			{
				await Task.Delay(50);
			}
			return SteamUtils.GetImage(largeFriendAvatar);
		}

		public static string GetRichPresence(string key)
		{
			if (richPresence.TryGetValue(key, out var value))
			{
				return value;
			}
			return null;
		}

		public static bool SetRichPresence(string key, string value)
		{
			bool num = Internal.SetRichPresence(key, value);
			if (num)
			{
				richPresence[key] = value;
			}
			return num;
		}

		public static void ClearRichPresence()
		{
			richPresence.Clear();
			Internal.ClearRichPresence();
		}

		public static async Task<bool> IsFollowing(SteamId steamID)
		{
			return (await Internal.IsFollowing(steamID)).Value.IsFollowing;
		}

		public static async Task<int> GetFollowerCount(SteamId steamID)
		{
			return (await Internal.GetFollowerCount(steamID)).Value.Count;
		}

		public static async Task<SteamId[]> GetFollowingList()
		{
			int resultCount = 0;
			List<SteamId> steamIds = new List<SteamId>();
			FriendsEnumerateFollowingList_t? friendsEnumerateFollowingList_t;
			do
			{
				FriendsEnumerateFollowingList_t? friendsEnumerateFollowingList_t2 = (friendsEnumerateFollowingList_t = await Internal.EnumerateFollowingList((uint)resultCount));
				if (!friendsEnumerateFollowingList_t2.HasValue)
				{
					continue;
				}
				resultCount += friendsEnumerateFollowingList_t.Value.ResultsReturned;
				Array.ForEach(friendsEnumerateFollowingList_t.Value.GSteamID, delegate(ulong id)
				{
					if (id != 0)
					{
						steamIds.Add(id);
					}
				});
			}
			while (friendsEnumerateFollowingList_t.HasValue && resultCount < friendsEnumerateFollowingList_t.Value.TotalResultCount);
			return steamIds.ToArray();
		}
	}
	public class SteamInput : SteamClientClass<SteamInput>
	{
		[CompilerGenerated]
		private sealed class <get_Controllers>d__7 : IEnumerable<Controller>, IEnumerable, IEnumerator<Controller>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private Controller <>2__current;

			private int <>l__initialThreadId;

			private int <num>5__2;

			private int <i>5__3;

			Controller IEnumerator<Controller>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <get_Controllers>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<num>5__2 = Internal.GetConnectedControllers(queryArray);
					<i>5__3 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__3++;
					break;
				}
				if (<i>5__3 < <num>5__2)
				{
					<>2__current = new Controller(queryArray[<i>5__3]);
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<Controller> IEnumerable<Controller>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <get_Controllers>d__7(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Controller>)this).GetEnumerator();
			}
		}

		internal const int STEAM_CONTROLLER_MAX_COUNT = 16;

		private static readonly InputHandle_t[] queryArray = new InputHandle_t[16];

		internal static Dictionary<string, InputDigitalActionHandle_t> DigitalHandles = new Dictionary<string, InputDigitalActionHandle_t>();

		internal static Dictionary<string, InputAnalogActionHandle_t> AnalogHandles = new Dictionary<string, InputAnalogActionHandle_t>();

		internal static Dictionary<string, InputActionSetHandle_t> ActionSets = new Dictionary<string, InputActionSetHandle_t>();

		internal static ISteamInput Internal => SteamClientClass<SteamInput>.Interface as ISteamInput;

		public static IEnumerable<Controller> Controllers
		{
			[IteratorStateMachine(typeof(<get_Controllers>d__7))]
			get
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <get_Controllers>d__7(-2);
			}
		}

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamInput(server));
		}

		public static void RunFrame()
		{
			Internal.RunFrame();
		}

		public static string GetDigitalActionGlyph(Controller controller, string action)
		{
			InputActionOrigin originsOut = InputActionOrigin.None;
			Internal.GetDigitalActionOrigins(controller.Handle, Internal.GetCurrentActionSet(controller.Handle), GetDigitalActionHandle(action), ref originsOut);
			return Internal.GetGlyphForActionOrigin(originsOut);
		}

		internal static InputDigitalActionHandle_t GetDigitalActionHandle(string name)
		{
			if (DigitalHandles.TryGetValue(name, out var value))
			{
				return value;
			}
			value = Internal.GetDigitalActionHandle(name);
			DigitalHandles.Add(name, value);
			return value;
		}

		internal static InputAnalogActionHandle_t GetAnalogActionHandle(string name)
		{
			if (AnalogHandles.TryGetValue(name, out var value))
			{
				return value;
			}
			value = Internal.GetAnalogActionHandle(name);
			AnalogHandles.Add(name, value);
			return value;
		}

		internal static InputActionSetHandle_t GetActionSetHandle(string name)
		{
			if (ActionSets.TryGetValue(name, out var value))
			{
				return value;
			}
			value = Internal.GetActionSetHandle(name);
			ActionSets.Add(name, value);
			return value;
		}
	}
	public class SteamInventory : SteamSharedClass<SteamInventory>
	{
		private static Dictionary<int, InventoryDef> _defMap;

		internal static ISteamInventory Internal => SteamSharedClass<SteamInventory>.Interface as ISteamInventory;

		public static string Currency { get; internal set; }

		public static InventoryItem[] Items { get; internal set; }

		public static InventoryDef[] Definitions { get; internal set; }

		public static event Action<InventoryResult> OnInventoryUpdated;

		public static event Action OnDefinitionsUpdated;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamInventory(server));
			InstallEvents(server);
		}

		internal static void InstallEvents(bool server)
		{
			if (!server)
			{
				Dispatch.Install(delegate(SteamInventoryFullUpdate_t x)
				{
					InventoryUpdated(x);
				});
			}
			Dispatch.Install<SteamInventoryDefinitionUpdate_t>(delegate
			{
				LoadDefinitions();
			}, server);
		}

		private static void InventoryUpdated(SteamInventoryFullUpdate_t x)
		{
			InventoryResult obj = new InventoryResult(x.Handle, expired: false);
			Items = obj.GetItems();
			SteamInventory.OnInventoryUpdated?.Invoke(obj);
		}

		private static void LoadDefinitions()
		{
			Definitions = GetDefinitions();
			if (Definitions != null)
			{
				_defMap = new Dictionary<int, InventoryDef>();
				InventoryDef[] definitions = Definitions;
				foreach (InventoryDef inventoryDef in definitions)
				{
					_defMap[inventoryDef.Id] = inventoryDef;
				}
				SteamInventory.OnDefinitionsUpdated?.Invoke();
			}
		}

		public static void LoadItemDefinitions()
		{
			if (Definitions == null)
			{
				LoadDefinitions();
			}
			Internal.LoadItemDefinitions();
		}

		public static async Task<bool> WaitForDefinitions(float timeoutSeconds = 30f)
		{
			if (Definitions != null)
			{
				return true;
			}
			LoadDefinitions();
			LoadItemDefinitions();
			if (Definitions != null)
			{
				return true;
			}
			Stopwatch sw = Stopwatch.StartNew();
			while (Definitions == null)
			{
				if (sw.Elapsed.TotalSeconds > (double)timeoutSeconds)
				{
					return false;
				}
				await Task.Delay(10);
			}
			return true;
		}

		public static InventoryDef FindDefinition(InventoryDefId defId)
		{
			if (_defMap == null)
			{
				return null;
			}
			if (_defMap.TryGetValue(defId, out var value))
			{
				return value;
			}
			return null;
		}

		public static async Task<InventoryDef[]> GetDefinitionsWithPricesAsync()
		{
			SteamInventoryRequestPricesResult_t? steamInventoryRequestPricesResult_t = await Internal.RequestPrices();
			if (!steamInventoryRequestPricesResult_t.HasValue || steamInventoryRequestPricesResult_t.Value.Result != Result.OK)
			{
				return null;
			}
			Currency = steamInventoryRequestPricesResult_t?.CurrencyUTF8();
			uint numItemsWithPrices = Internal.GetNumItemsWithPrices();
			if (numItemsWithPrices == 0)
			{
				return null;
			}
			InventoryDefId[] array = new InventoryDefId[numItemsWithPrices];
			ulong[] pCurrentPrices = new ulong[numItemsWithPrices];
			ulong[] pBasePrices = new ulong[numItemsWithPrices];
			if (!Internal.GetItemsWithPrices(array, pCurrentPrices, pBasePrices, numItemsWithPrices))
			{
				return null;
			}
			return array.Select((InventoryDefId x) => new InventoryDef(x)).ToArray();
		}

		internal static InventoryDef[] GetDefinitions()
		{
			uint punItemDefIDsArraySize = 0u;
			if (!Internal.GetItemDefinitionIDs(null, ref punItemDefIDsArraySize))
			{
				return null;
			}
			InventoryDefId[] array = new InventoryDefId[punItemDefIDsArraySize];
			if (!Internal.GetItemDefinitionIDs(array, ref punItemDefIDsArraySize))
			{
				return null;
			}
			return array.Select((InventoryDefId x) => new InventoryDef(x)).ToArray();
		}

		public static bool GetAllItems()
		{
			SteamInventoryResult_t pResultHandle = Defines.k_SteamInventoryResultInvalid;
			return Internal.GetAllItems(ref pResultHandle);
		}

		public static async Task<InventoryResult?> GetAllItemsAsync()
		{
			SteamInventoryResult_t pResultHandle = Defines.k_SteamInventoryResultInvalid;
			if (!Internal.GetAllItems(ref pResultHandle))
			{
				return null;
			}
			return await InventoryResult.GetAsync(pResultHandle);
		}

		public static async Task<InventoryResult?> GenerateItemAsync(InventoryDef target, int amount)
		{
			SteamInventoryResult_t pResultHandle = Defines.k_SteamInventoryResultInvalid;
			InventoryDefId[] pArrayItemDefs = new InventoryDefId[1] { target.Id };
			uint[] punArrayQuantity = new uint[1] { (uint)amount };
			if (!Internal.GenerateItems(ref pResultHandle, pArrayItemDefs, punArrayQuantity, 1u))
			{
				return null;
			}
			return await InventoryResult.GetAsync(pResultHandle);
		}

		public static async Task<InventoryResult?> CraftItemAsync(InventoryItem[] list, InventoryDef target)
		{
			SteamInventoryResult_t pResultHandle = Defines.k_SteamInventoryResultInvalid;
			InventoryDefId[] pArrayGenerate = new InventoryDefId[1] { target.Id };
			uint[] punArrayGenerateQuantity = new uint[1] { 1u };
			InventoryItemId[] array = list.Select((InventoryItem x) => x.Id).ToArray();
			uint[] punArrayDestroyQuantity = list.Select((InventoryItem x) => 1u).ToArray();
			if (!Internal.ExchangeItems(ref pResultHandle, pArrayGenerate, punArrayGenerateQuantity, 1u, array, punArrayDestroyQuantity, (uint)array.Length))
			{
				return null;
			}
			return await InventoryResult.GetAsync(pResultHandle);
		}

		public static async Task<InventoryResult?> CraftItemAsync(InventoryItem.Amount[] list, InventoryDef target)
		{
			SteamInventoryResult_t pResultHandle = Defines.k_SteamInventoryResultInvalid;
			InventoryDefId[] pArrayGenerate = new InventoryDefId[1] { target.Id };
			uint[] punArrayGenerateQuantity = new uint[1] { 1u };
			InventoryItemId[] array = list.Select((InventoryItem.Amount x) => x.Item.Id).ToArray();
			uint[] punArrayDestroyQuantity = list.Select((InventoryItem.Amount x) => (uint)x.Quantity).ToArray();
			if (!Internal.ExchangeItems(ref pResultHandle, pArrayGenerate, punArrayGenerateQuantity, 1u, array, punArrayDestroyQuantity, (uint)array.Length))
			{
				return null;
			}
			return await InventoryResult.GetAsync(pResultHandle);
		}

		public static async Task<InventoryResult?> DeserializeAsync(byte[] data, int dataLength = -1)
		{
			if (data == null)
			{
				throw new ArgumentException("data should not be null");
			}
			if (dataLength == -1)
			{
				dataLength = data.Length;
			}
			IntPtr ptr = Marshal.AllocHGlobal(dataLength);
			try
			{
				Marshal.Copy(data, 0, ptr, dataLength);
				SteamInventoryResult_t pOutResultHandle = Defines.k_SteamInventoryResultInvalid;
				if (!Internal.DeserializeResult(ref pOutResultHandle, ptr, (uint)dataLength, bRESERVED_MUST_BE_FALSE: false))
				{
					return null;
				}
				return await InventoryResult.GetAsync(pOutResultHandle.Value);
			}
			finally
			{
				Marshal.FreeHGlobal(ptr);
			}
		}

		public static async Task<InventoryResult?> GrantPromoItemsAsync()
		{
			SteamInventoryResult_t pResultHandle = Defines.k_SteamInventoryResultInvalid;
			if (!Internal.GrantPromoItems(ref pResultHandle))
			{
				return null;
			}
			return await InventoryResult.GetAsync(pResultHandle);
		}

		public static async Task<InventoryResult?> TriggerItemDropAsync(InventoryDefId id)
		{
			SteamInventoryResult_t pResultHandle = Defines.k_SteamInventoryResultInvalid;
			if (!Internal.TriggerItemDrop(ref pResultHandle, id))
			{
				return null;
			}
			return await InventoryResult.GetAsync(pResultHandle);
		}

		public static async Task<InventoryResult?> AddPromoItemAsync(InventoryDefId id)
		{
			SteamInventoryResult_t pResultHandle = Defines.k_SteamInventoryResultInvalid;
			if (!Internal.AddPromoItem(ref pResultHandle, id))
			{
				return null;
			}
			return await InventoryResult.GetAsync(pResultHandle);
		}

		public static async Task<InventoryPurchaseResult?> StartPurchaseAsync(InventoryDef[] items)
		{
			InventoryDefId[] array = items.Select((InventoryDef x) => x._id).ToArray();
			uint[] punArrayQuantity = items.Select((InventoryDef x) => 1u).ToArray();
			SteamInventoryStartPurchaseResult_t? steamInventoryStartPurchaseResult_t = await Internal.StartPurchase(array, punArrayQuantity, (uint)array.Length);
			if (!steamInventoryStartPurchaseResult_t.HasValue)
			{
				return null;
			}
			InventoryPurchaseResult value = default(InventoryPurchaseResult);
			value.Result = steamInventoryStartPurchaseResult_t.Value.Result;
			value.OrderID = steamInventoryStartPurchaseResult_t.Value.OrderID;
			value.TransID = steamInventoryStartPurchaseResult_t.Value.TransID;
			return value;
		}
	}
	public class SteamMatchmaking : SteamClientClass<SteamMatchmaking>
	{
		[CompilerGenerated]
		private sealed class <GetFavoriteServers>d__47 : IEnumerable<ServerInfo>, IEnumerable, IEnumerator<ServerInfo>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private ServerInfo <>2__current;

			private int <>l__initialThreadId;

			private int <count>5__2;

			private int <i>5__3;

			ServerInfo IEnumerator<ServerInfo>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetFavoriteServers>d__47(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0088;
				}
				<>1__state = -1;
				<count>5__2 = Internal.GetFavoriteGameCount();
				<i>5__3 = 0;
				goto IL_009a;
				IL_0088:
				<i>5__3++;
				goto IL_009a;
				IL_009a:
				if (<i>5__3 < <count>5__2)
				{
					uint pRTime32LastPlayedOnServer = 0u;
					uint punFlags = 0u;
					ushort pnQueryPort = 0;
					ushort pnConnPort = 0;
					uint pnIP = 0u;
					AppId pnAppID = default(AppId);
					if (Internal.GetFavoriteGame(<i>5__3, ref pnAppID, ref pnIP, ref pnConnPort, ref pnQueryPort, ref punFlags, ref pRTime32LastPlayedOnServer) && (punFlags & (true ? 1u : 0u)) != 0)
					{
						<>2__current = new ServerInfo(pnIP, pnConnPort, pnQueryPort, pRTime32LastPlayedOnServer);
						<>1__state = 1;
						return true;
					}
					goto IL_0088;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<ServerInfo> IEnumerable<ServerInfo>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetFavoriteServers>d__47(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<ServerInfo>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GetHistoryServers>d__48 : IEnumerable<ServerInfo>, IEnumerable, IEnumerator<ServerInfo>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private ServerInfo <>2__current;

			private int <>l__initialThreadId;

			private int <count>5__2;

			private int <i>5__3;

			ServerInfo IEnumerator<ServerInfo>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetHistoryServers>d__48(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0088;
				}
				<>1__state = -1;
				<count>5__2 = Internal.GetFavoriteGameCount();
				<i>5__3 = 0;
				goto IL_009a;
				IL_0088:
				<i>5__3++;
				goto IL_009a;
				IL_009a:
				if (<i>5__3 < <count>5__2)
				{
					uint pRTime32LastPlayedOnServer = 0u;
					uint punFlags = 0u;
					ushort pnQueryPort = 0;
					ushort pnConnPort = 0;
					uint pnIP = 0u;
					AppId pnAppID = default(AppId);
					if (Internal.GetFavoriteGame(<i>5__3, ref pnAppID, ref pnIP, ref pnConnPort, ref pnQueryPort, ref punFlags, ref pRTime32LastPlayedOnServer) && (punFlags & 2u) != 0)
					{
						<>2__current = new ServerInfo(pnIP, pnConnPort, pnQueryPort, pRTime32LastPlayedOnServer);
						<>1__state = 1;
						return true;
					}
					goto IL_0088;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<ServerInfo> IEnumerable<ServerInfo>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetHistoryServers>d__48(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<ServerInfo>)this).GetEnumerator();
			}
		}

		internal static ISteamMatchmaking Internal => SteamClientClass<SteamMatchmaking>.Interface as ISteamMatchmaking;

		internal static int MaxLobbyKeyLength => 255;

		public static LobbyQuery LobbyList => default(LobbyQuery);

		public static event Action<Friend, Lobby> OnLobbyInvite;

		public static event Action<Lobby> OnLobbyEntered;

		public static event Action<Result, Lobby> OnLobbyCreated;

		public static event Action<Lobby, uint, ushort, SteamId> OnLobbyGameCreated;

		public static event Action<Lobby> OnLobbyDataChanged;

		public static event Action<Lobby, Friend> OnLobbyMemberDataChanged;

		public static event Action<Lobby, Friend> OnLobbyMemberJoined;

		public static event Action<Lobby, Friend> OnLobbyMemberLeave;

		public static event Action<Lobby, Friend> OnLobbyMemberDisconnected;

		public static event Action<Lobby, Friend, Friend> OnLobbyMemberKicked;

		public static event Action<Lobby, Friend, Friend> OnLobbyMemberBanned;

		public static event Action<Lobby, Friend, string> OnChatMessage;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamMatchmaking(server));
			InstallEvents();
		}

		internal static void InstallEvents()
		{
			Dispatch.Install(delegate(LobbyInvite_t x)
			{
				SteamMatchmaking.OnLobbyInvite?.Invoke(new Friend(x.SteamIDUser), new Lobby(x.SteamIDLobby));
			});
			Dispatch.Install(delegate(LobbyEnter_t x)
			{
				SteamMatchmaking.OnLobbyEntered?.Invoke(new Lobby(x.SteamIDLobby));
			});
			Dispatch.Install(delegate(LobbyCreated_t x)
			{
				SteamMatchmaking.OnLobbyCreated?.Invoke(x.Result, new Lobby(x.SteamIDLobby));
			});
			Dispatch.Install(delegate(LobbyGameCreated_t x)
			{
				SteamMatchmaking.OnLobbyGameCreated?.Invoke(new Lobby(x.SteamIDLobby), x.IP, x.Port, x.SteamIDGameServer);
			});
			Dispatch.Install(delegate(LobbyDataUpdate_t x)
			{
				if (x.Success != 0)
				{
					if (x.SteamIDLobby == x.SteamIDMember)
					{
						SteamMatchmaking.OnLobbyDataChanged?.Invoke(new Lobby(x.SteamIDLobby));
					}
					else
					{
						SteamMatchmaking.OnLobbyMemberDataChanged?.Invoke(new Lobby(x.SteamIDLobby), new Friend(x.SteamIDMember));
					}
				}
			});
			Dispatch.Install(delegate(LobbyChatUpdate_t x)
			{
				if ((x.GfChatMemberStateChange & (true ? 1u : 0u)) != 0)
				{
					SteamMatchmaking.OnLobbyMemberJoined?.Invoke(new Lobby(x.SteamIDLobby), new Friend(x.SteamIDUserChanged));
				}
				if ((x.GfChatMemberStateChange & 2u) != 0)
				{
					SteamMatchmaking.OnLobbyMemberLeave?.Invoke(new Lobby(x.SteamIDLobby), new Friend(x.SteamIDUserChanged));
				}
				if ((x.GfChatMemberStateChange & 4u) != 0)
				{
					SteamMatchmaking.OnLobbyMemberDisconnected?.Invoke(new Lobby(x.SteamIDLobby), new Friend(x.SteamIDUserChanged));
				}
				if ((x.GfChatMemberStateChange & 8u) != 0)
				{
					SteamMatchmaking.OnLobbyMemberKicked?.Invoke(new Lobby(x.SteamIDLobby), new Friend(x.SteamIDUserChanged), new Friend(x.SteamIDMakingChange));
				}
				if ((x.GfChatMemberStateChange & 0x10u) != 0)
				{
					SteamMatchmaking.OnLobbyMemberBanned?.Invoke(new Lobby(x.SteamIDLobby), new Friend(x.SteamIDUserChanged), new Friend(x.SteamIDMakingChange));
				}
			});
			Dispatch.Install<LobbyChatMsg_t>(OnLobbyChatMessageRecievedAPI);
		}

		private unsafe static void OnLobbyChatMessageRecievedAPI(LobbyChatMsg_t callback)
		{
			SteamId pSteamIDUser = default(SteamId);
			ChatEntryType peChatEntryType = ChatEntryType.Invalid;
			byte[] array = Helpers.TakeBuffer(4096);
			fixed (byte* ptr = array)
			{
				int lobbyChatEntry = Internal.GetLobbyChatEntry(callback.SteamIDLobby, (int)callback.ChatID, ref pSteamIDUser, (IntPtr)ptr, array.Length, ref peChatEntryType);
				if (lobbyChatEntry > 0)
				{
					SteamMatchmaking.OnChatMessage?.Invoke(new Lobby(callback.SteamIDLobby), new Friend(pSteamIDUser), Encoding.UTF8.GetString(array, 0, lobbyChatEntry));
				}
			}
		}

		public static async Task<Lobby?> CreateLobbyAsync(int maxMembers = 100)
		{
			LobbyCreated_t? lobbyCreated_t = await Internal.CreateLobby(LobbyType.Invisible, maxMembers);
			if (!lobbyCreated_t.HasValue || lobbyCreated_t.Value.Result != Result.OK)
			{
				return null;
			}
			Lobby value = default(Lobby);
			value.Id = lobbyCreated_t.Value.SteamIDLobby;
			return value;
		}

		public static async Task<Lobby?> JoinLobbyAsync(SteamId lobbyId)
		{
			LobbyEnter_t? lobbyEnter_t = await Internal.JoinLobby(lobbyId);
			if (!lobbyEnter_t.HasValue)
			{
				return null;
			}
			Lobby value = default(Lobby);
			value.Id = lobbyEnter_t.Value.SteamIDLobby;
			return value;
		}

		[IteratorStateMachine(typeof(<GetFavoriteServers>d__47))]
		public static IEnumerable<ServerInfo> GetFavoriteServers()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetFavoriteServers>d__47(-2);
		}

		[IteratorStateMachine(typeof(<GetHistoryServers>d__48))]
		public static IEnumerable<ServerInfo> GetHistoryServers()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetHistoryServers>d__48(-2);
		}
	}
	public class SteamMatchmakingServers : SteamClientClass<SteamMatchmakingServers>
	{
		internal static ISteamMatchmakingServers Internal => SteamClientClass<SteamMatchmakingServers>.Interface as ISteamMatchmakingServers;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamMatchmakingServers(server));
		}
	}
	public class SteamMusic : SteamClientClass<SteamMusic>
	{
		internal static ISteamMusic Internal => SteamClientClass<SteamMusic>.Interface as ISteamMusic;

		public static bool IsEnabled => Internal.BIsEnabled();

		public static bool IsPlaying => Internal.BIsPlaying();

		public static MusicStatus Status => Internal.GetPlaybackStatus();

		public static float Volume
		{
			get
			{
				return Internal.GetVolume();
			}
			set
			{
				Internal.SetVolume(value);
			}
		}

		public static event Action OnPlaybackChanged;

		public static event Action<float> OnVolumeChanged;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamMusic(server));
			InstallEvents();
		}

		internal static void InstallEvents()
		{
			Dispatch.Install<PlaybackStatusHasChanged_t>(delegate
			{
				SteamMusic.OnPlaybackChanged?.Invoke();
			});
			Dispatch.Install(delegate(VolumeHasChanged_t x)
			{
				SteamMusic.OnVolumeChanged?.Invoke(x.NewVolume);
			});
		}

		public static void Play()
		{
			Internal.Play();
		}

		public static void Pause()
		{
			Internal.Pause();
		}

		public static void PlayPrevious()
		{
			Internal.PlayPrevious();
		}

		public static void PlayNext()
		{
			Internal.PlayNext();
		}
	}
	public class SteamNetworking : SteamSharedClass<SteamNetworking>
	{
		public static Action<SteamId> OnP2PSessionRequest;

		public static Action<SteamId, P2PSessionError> OnP2PConnectionFailed;

		internal static ISteamNetworking Internal => SteamSharedClass<SteamNetworking>.Interface as ISteamNetworking;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamNetworking(server));
			InstallEvents(server);
		}

		internal static void InstallEvents(bool server)
		{
			Dispatch.Install(delegate(P2PSessionRequest_t x)
			{
				OnP2PSessionRequest?.Invoke(x.SteamIDRemote);
			}, server);
			Dispatch.Install(delegate(P2PSessionConnectFail_t x)
			{
				OnP2PConnectionFailed?.Invoke(x.SteamIDRemote, (P2PSessionError)x.P2PSessionError);
			}, server);
		}

		public static bool AcceptP2PSessionWithUser(SteamId user)
		{
			return Internal.AcceptP2PSessionWithUser(user);
		}

		public static bool AllowP2PPacketRelay(bool allow)
		{
			return Internal.AllowP2PPacketRelay(allow);
		}

		public static bool CloseP2PSessionWithUser(SteamId user)
		{
			return Internal.CloseP2PSessionWithUser(user);
		}

		public static bool IsP2PPacketAvailable(int channel = 0)
		{
			uint pcubMsgSize = 0u;
			return Internal.IsP2PPacketAvailable(ref pcubMsgSize, channel);
		}

		public unsafe static P2Packet? ReadP2PPacket(int channel = 0)
		{
			uint pcubMsgSize = 0u;
			if (!Internal.IsP2PPacketAvailable(ref pcubMsgSize, channel))
			{
				return null;
			}
			byte[] array = Helpers.TakeBuffer((int)pcubMsgSize);
			fixed (byte* ptr = array)
			{
				SteamId psteamIDRemote = 1uL;
				if (!Internal.ReadP2PPacket((IntPtr)ptr, (uint)array.Length, ref pcubMsgSize, ref psteamIDRemote, channel) || pcubMsgSize == 0)
				{
					return null;
				}
				byte[] array2 = new byte[pcubMsgSize];
				Array.Copy(array, 0L, array2, 0L, pcubMsgSize);
				P2Packet value = default(P2Packet);
				value.SteamId = psteamIDRemote;
				value.Data = array2;
				return value;
			}
		}

		public unsafe static bool ReadP2PPacket(byte[] buffer, ref uint size, ref SteamId steamid, int channel = 0)
		{
			fixed (byte* ptr = buffer)
			{
				return Internal.ReadP2PPacket((IntPtr)ptr, (uint)buffer.Length, ref size, ref steamid, channel);
			}
		}

		public unsafe static bool ReadP2PPacket(byte* buffer, uint cbuf, ref uint size, ref SteamId steamid, int channel = 0)
		{
			return Internal.ReadP2PPacket((IntPtr)buffer, cbuf, ref size, ref steamid, channel);
		}

		public unsafe static bool SendP2PPacket(SteamId steamid, byte[] data, int length = -1, int nChannel = 0, P2PSend sendType = P2PSend.Reliable)
		{
			if (length <= 0)
			{
				length = data.Length;
			}
			fixed (byte* ptr = data)
			{
				return Internal.SendP2PPacket(steamid, (IntPtr)ptr, (uint)length, sendType, nChannel);
			}
		}

		public unsafe static bool SendP2PPacket(SteamId steamid, byte* data, uint length, int nChannel = 1, P2PSend sendType = P2PSend.Reliable)
		{
			return Internal.SendP2PPacket(steamid, (IntPtr)data, length, sendType, nChannel);
		}
	}
	public class SteamNetworkingSockets : SteamSharedClass<SteamNetworkingSockets>
	{
		private static readonly Dictionary<uint, SocketManager> SocketInterfaces = new Dictionary<uint, SocketManager>();

		private static readonly Dictionary<uint, ConnectionManager> ConnectionInterfaces = new Dictionary<uint, ConnectionManager>();

		internal static ISteamNetworkingSockets Internal => SteamSharedClass<SteamNetworkingSockets>.Interface as ISteamNetworkingSockets;

		public static event Action<Connection, ConnectionInfo> OnConnectionStatusChanged;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamNetworkingSockets(server));
			InstallEvents(server);
		}

		internal static SocketManager GetSocketManager(uint id)
		{
			if (SocketInterfaces == null)
			{
				return null;
			}
			if (id == 0)
			{
				throw new ArgumentException("Invalid Socket");
			}
			if (SocketInterfaces.TryGetValue(id, out var value))
			{
				return value;
			}
			return null;
		}

		internal static void SetSocketManager(uint id, SocketManager manager)
		{
			if (id == 0)
			{
				throw new ArgumentException("Invalid Socket");
			}
			SocketInterfaces[id] = manager;
		}

		internal static ConnectionManager GetConnectionManager(uint id)
		{
			if (ConnectionInterfaces == null)
			{
				return null;
			}
			if (id == 0)
			{
				return null;
			}
			if (ConnectionInterfaces.TryGetValue(id, out var value))
			{
				return value;
			}
			return null;
		}

		internal static void SetConnectionManager(uint id, ConnectionManager manager)
		{
			if (id == 0)
			{
				throw new ArgumentException("Invalid Connection");
			}
			ConnectionInterfaces[id] = manager;
		}

		internal void InstallEvents(bool server)
		{
			Dispatch.Install<SteamNetConnectionStatusChangedCallback_t>(ConnectionStatusChanged, server);
		}

		private static void ConnectionStatusChanged(SteamNetConnectionStatusChangedCallback_t data)
		{
			if (data.Nfo.listenSocket.Id != 0)
			{
				GetSocketManager(data.Nfo.listenSocket.Id)?.OnConnectionChanged(data.Conn, data.Nfo);
			}
			else
			{
				GetConnectionManager(data.Conn.Id)?.OnConnectionChanged(data.Nfo);
			}
			SteamNetworkingSockets.OnConnectionStatusChanged?.Invoke(data.Conn, data.Nfo);
		}

		public static T CreateNormalSocket<T>(NetAddress address) where T : SocketManager, new()
		{
			T val = new T();
			NetKeyValue[] array = Array.Empty<NetKeyValue>();
			val.Socket = Internal.CreateListenSocketIP(ref address, array.Length, array);
			val.Initialize();
			SetSocketManager(val.Socket.Id, val);
			return val;
		}

		public static SocketManager CreateNormalSocket(NetAddress address, ISocketManager intrface)
		{
			NetKeyValue[] array = Array.Empty<NetKeyValue>();
			Steamworks.Data.Socket socket = Internal.CreateListenSocketIP(ref address, array.Length, array);
			SocketManager socketManager = new SocketManager
			{
				Socket = socket,
				Interface = intrface
			};
			socketManager.Initialize();
			SetSocketManager(socketManager.Socket.Id, socketManager);
			return socketManager;
		}

		public static T ConnectNormal<T>(NetAddress address) where T : ConnectionManager, new()
		{
			T val = new T();
			NetKeyValue[] array = Array.Empty<NetKeyValue>();
			val.Connection = Internal.ConnectByIPAddress(ref address, array.Length, array);
			SetConnectionManager(val.Connection.Id, val);
			return val;
		}

		public static ConnectionManager ConnectNormal(NetAddress address, IConnectionManager iface)
		{
			NetKeyValue[] array = Array.Empty<NetKeyValue>();
			Connection connection = Internal.ConnectByIPAddress(ref address, array.Length, array);
			ConnectionManager connectionManager = new ConnectionManager
			{
				Connection = connection,
				Interface = iface
			};
			SetConnectionManager(connectionManager.Connection.Id, connectionManager);
			return connectionManager;
		}

		public static T CreateRelaySocket<T>(int virtualport = 0) where T : SocketManager, new()
		{
			T val = new T();
			NetKeyValue[] array = Array.Empty<NetKeyValue>();
			val.Socket = Internal.CreateListenSocketP2P(virtualport, array.Length, array);
			val.Initialize();
			SetSocketManager(val.Socket.Id, val);
			return val;
		}

		public static T ConnectRelay<T>(SteamId serverId, int virtualport = 0) where T : ConnectionManager, new()
		{
			T val = new T();
			NetIdentity identityRemote = serverId;
			NetKeyValue[] array = Array.Empty<NetKeyValue>();
			val.Connection = Internal.ConnectP2P(ref identityRemote, virtualport, array.Length, array);
			SetConnectionManager(val.Connection.Id, val);
			return val;
		}
	}
	public class SteamNetworkingUtils : SteamSharedClass<SteamNetworkingUtils>
	{
		private struct DebugMessage
		{
			public NetDebugOutput Type;

			public string Msg;
		}

		private static NetDebugOutput _debugLevel;

		private static NetDebugFunc _debugFunc;

		private static ConcurrentQueue<DebugMessage> debugMessages = new ConcurrentQueue<DebugMessage>();

		internal static ISteamNetworkingUtils Internal => SteamSharedClass<SteamNetworkingUtils>.Interface as ISteamNetworkingUtils;

		public static SteamNetworkingAvailability Status { get; private set; }

		public static NetPingLocation? LocalPingLocation
		{
			get
			{
				NetPingLocation result = default(NetPingLocation);
				if (Internal.GetLocalPingLocation(ref result) < 0f)
				{
					return null;
				}
				return result;
			}
		}

		public static long LocalTimestamp => Internal.GetLocalTimestamp();

		public static float FakeSendPacketLoss
		{
			get
			{
				return GetConfigFloat(NetConfig.FakePacketLoss_Send);
			}
			set
			{
				SetConfigFloat(NetConfig.FakePacketLoss_Send, value);
			}
		}

		public static float FakeRecvPacketLoss
		{
			get
			{
				return GetConfigFloat(NetConfig.FakePacketLoss_Recv);
			}
			set
			{
				SetConfigFloat(NetConfig.FakePacketLoss_Recv, value);
			}
		}

		public static float FakeSendPacketLag
		{
			get
			{
				return GetConfigFloat(NetConfig.FakePacketLag_Send);
			}
			set
			{
				SetConfigFloat(NetConfig.FakePacketLag_Send, value);
			}
		}

		public static float FakeRecvPacketLag
		{
			get
			{
				return GetConfigFloat(NetConfig.FakePacketLag_Recv);
			}
			set
			{
				SetConfigFloat(NetConfig.FakePacketLag_Recv, value);
			}
		}

		public static int ConnectionTimeout
		{
			get
			{
				return GetConfigInt(NetConfig.TimeoutInitial);
			}
			set
			{
				SetConfigInt(NetConfig.TimeoutInitial, value);
			}
		}

		public static int Timeout
		{
			get
			{
				return GetConfigInt(NetConfig.TimeoutConnected);
			}
			set
			{
				SetConfigInt(NetConfig.TimeoutConnected, value);
			}
		}

		public static int SendBufferSize
		{
			get
			{
				return GetConfigInt(NetConfig.SendBufferSize);
			}
			set
			{
				SetConfigInt(NetConfig.SendBufferSize, value);
			}
		}

		public static NetDebugOutput DebugLevel
		{
			get
			{
				return _debugLevel;
			}
			set
			{
				_debugLevel = value;
				_debugFunc = OnDebugMessage;
				Internal.SetDebugOutputFunction(value, _debugFunc);
			}
		}

		public static event Action<NetDebugOutput, string> OnDebugOutput;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamNetworkingUtils(server));
			InstallCallbacks(server);
		}

		private static void InstallCallbacks(bool server)
		{
			Dispatch.Install(delegate(SteamRelayNetworkStatus_t x)
			{
				Status = x.Avail;
			}, server);
		}

		public static void InitRelayNetworkAccess()
		{
			Internal.InitRelayNetworkAccess();
		}

		public static int EstimatePingTo(NetPingLocation target)
		{
			return Internal.EstimatePingTimeFromLocalHost(ref target);
		}

		public static async Task WaitForPingDataAsync(float maxAgeInSeconds = 300f)
		{
			if (!Internal.CheckPingDataUpToDate(maxAgeInSeconds))
			{
				SteamRelayNetworkStatus_t status = default(SteamRelayNetworkStatus_t);
				while (Internal.GetRelayNetworkStatus(ref status) != SteamNetworkingAvailability.Current)
				{
					await Task.Delay(10);
				}
			}
		}

		[MonoPInvokeCallback]
		private static void OnDebugMessage(NetDebugOutput nType, IntPtr str)
		{
			debugMessages.Enqueue(new DebugMessage
			{
				Type = nType,
				Msg = Helpers.MemoryToString(str)
			});
		}

		internal static void OutputDebugMessages()
		{
			if (!debugMessages.IsEmpty)
			{
				DebugMessage result;
				while (debugMessages.TryDequeue(out result))
				{
					SteamNetworkingUtils.OnDebugOutput?.Invoke(result.Type, result.Msg);
				}
			}
		}

		internal unsafe static bool SetConfigInt(NetConfig type, int value)
		{
			int* ptr = &value;
			return Internal.SetConfigValue(type, NetConfigScope.Global, IntPtr.Zero, NetConfigType.Int32, (IntPtr)ptr);
		}

		internal unsafe static int GetConfigInt(NetConfig type)
		{
			int result = 0;
			NetConfigType pOutDataType = NetConfigType.Int32;
			int* ptr = &result;
			UIntPtr cbResult = new UIntPtr(4u);
			if (Internal.GetConfigValue(type, NetConfigScope.Global, IntPtr.Zero, ref pOutDataType, (IntPtr)ptr, ref cbResult) != NetConfigResult.OK)
			{
				return 0;
			}
			return result;
		}

		internal unsafe static bool SetConfigFloat(NetConfig type, float value)
		{
			float* ptr = &value;
			return Internal.SetConfigValue(type, NetConfigScope.Global, IntPtr.Zero, NetConfigType.Float, (IntPtr)ptr);
		}

		internal unsafe static float GetConfigFloat(NetConfig type)
		{
			float result = 0f;
			NetConfigType pOutDataType = NetConfigType.Float;
			float* ptr = &result;
			UIntPtr cbResult = new UIntPtr(4u);
			if (Internal.GetConfigValue(type, NetConfigScope.Global, IntPtr.Zero, ref pOutDataType, (IntPtr)ptr, ref cbResult) != NetConfigResult.OK)
			{
				return 0f;
			}
			return result;
		}

		internal unsafe static bool SetConfigString(NetConfig type, string value)
		{
			fixed (byte* ptr = Encoding.UTF8.GetBytes(value))
			{
				return Internal.SetConfigValue(type, NetConfigScope.Global, IntPtr.Zero, NetConfigType.String, (IntPtr)ptr);
			}
		}
	}
	public class SteamParental : SteamSharedClass<SteamParental>
	{
		internal static ISteamParentalSettings Internal => SteamSharedClass<SteamParental>.Interface as ISteamParentalSettings;

		public static bool IsParentalLockEnabled => Internal.BIsParentalLockEnabled();

		public static bool IsParentalLockLocked => Internal.BIsParentalLockLocked();

		public static event Action OnSettingsChanged;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamParentalSettings(server));
			InstallEvents(server);
		}

		internal static void InstallEvents(bool server)
		{
			Dispatch.Install<SteamParentalSettingsChanged_t>(delegate
			{
				SteamParental.OnSettingsChanged?.Invoke();
			}, server);
		}

		public static bool IsAppBlocked(AppId app)
		{
			return Internal.BIsAppBlocked(app.Value);
		}

		public static bool BIsAppInBlockList(AppId app)
		{
			return Internal.BIsAppInBlockList(app.Value);
		}

		public static bool IsFeatureBlocked(ParentalFeature feature)
		{
			return Internal.BIsFeatureBlocked(feature);
		}

		public static bool BIsFeatureInBlockList(ParentalFeature feature)
		{
			return Internal.BIsFeatureInBlockList(feature);
		}
	}
	public class SteamParties : SteamClientClass<SteamParties>
	{
		[CompilerGenerated]
		private sealed class <get_ActiveBeacons>d__13 : IEnumerable<PartyBeacon>, IEnumerable, IEnumerator<PartyBeacon>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private PartyBeacon <>2__current;

			private int <>l__initialThreadId;

			private uint <i>5__2;

			PartyBeacon IEnumerator<PartyBeacon>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <get_ActiveBeacons>d__13(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0u;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < ActiveBeaconCount)
				{
					<>2__current = new PartyBeacon
					{
						Id = Internal.GetBeaconByIndex(<i>5__2)
					};
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<PartyBeacon> IEnumerable<PartyBeacon>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <get_ActiveBeacons>d__13(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<PartyBeacon>)this).GetEnumerator();
			}
		}

		internal static ISteamParties Internal => SteamClientClass<SteamParties>.Interface as ISteamParties;

		public static int ActiveBeaconCount => (int)Internal.GetNumActiveBeacons();

		public static IEnumerable<PartyBeacon> ActiveBeacons
		{
			[IteratorStateMachine(typeof(<get_ActiveBeacons>d__13))]
			get
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <get_ActiveBeacons>d__13(-2);
			}
		}

		public static event Action OnBeaconLocationsUpdated;

		public static event Action OnActiveBeaconsUpdated;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamParties(server));
			InstallEvents(server);
		}

		internal void InstallEvents(bool server)
		{
			Dispatch.Install<AvailableBeaconLocationsUpdated_t>(delegate
			{
				SteamParties.OnBeaconLocationsUpdated?.Invoke();
			}, server);
			Dispatch.Install<ActiveBeaconsUpdated_t>(delegate
			{
				SteamParties.OnActiveBeaconsUpdated?.Invoke();
			}, server);
		}
	}
	public class SteamRemotePlay : SteamClientClass<SteamRemotePlay>
	{
		internal static ISteamRemotePlay Internal => SteamClientClass<SteamRemotePlay>.Interface as ISteamRemotePlay;

		public static int SessionCount => (int)Internal.GetSessionCount();

		public static event Action<RemotePlaySession> OnSessionConnected;

		public static event Action<RemotePlaySession> OnSessionDisconnected;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamRemotePlay(server));
			InstallEvents(server);
		}

		internal void InstallEvents(bool server)
		{
			Dispatch.Install(delegate(SteamRemotePlaySessionConnected_t x)
			{
				SteamRemotePlay.OnSessionConnected?.Invoke(x.SessionID);
			}, server);
			Dispatch.Install(delegate(SteamRemotePlaySessionDisconnected_t x)
			{
				SteamRemotePlay.OnSessionDisconnected?.Invoke(x.SessionID);
			}, server);
		}

		public static RemotePlaySession GetSession(int index)
		{
			return Internal.GetSessionID(index).Value;
		}

		public static bool SendInvite(SteamId steamid)
		{
			return Internal.BSendRemotePlayTogetherInvite(steamid);
		}
	}
	public class SteamRemoteStorage : SteamClientClass<SteamRemoteStorage>
	{
		[CompilerGenerated]
		private sealed class <get_Files>d__27 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private int <_>5__2;

			private int <i>5__3;

			string IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <get_Files>d__27(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<_>5__2 = 0;
					<i>5__3 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__3++;
					break;
				}
				if (<i>5__3 < FileCount)
				{
					string fileNameAndSize = Internal.GetFileNameAndSize(<i>5__3, ref <_>5__2);
					<>2__current = fileNameAndSize;
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <get_Files>d__27(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		internal static ISteamRemoteStorage Internal => SteamClientClass<SteamRemoteStorage>.Interface as ISteamRemoteStorage;

		public static ulong QuotaBytes
		{
			get
			{
				ulong pnTotalBytes = 0uL;
				ulong puAvailableBytes = 0uL;
				Internal.GetQuota(ref pnTotalBytes, ref puAvailableBytes);
				return pnTotalBytes;
			}
		}

		public static ulong QuotaUsedBytes
		{
			get
			{
				ulong pnTotalBytes = 0uL;
				ulong puAvailableBytes = 0uL;
				Internal.GetQuota(ref pnTotalBytes, ref puAvailableBytes);
				return pnTotalBytes - puAvailableBytes;
			}
		}

		public static ulong QuotaRemainingBytes
		{
			get
			{
				ulong pnTotalBytes = 0uL;
				ulong puAvailableBytes = 0uL;
				Internal.GetQuota(ref pnTotalBytes, ref puAvailableBytes);
				return puAvailableBytes;
			}
		}

		public static bool IsCloudEnabled
		{
			get
			{
				if (IsCloudEnabledForAccount)
				{
					return IsCloudEnabledForApp;
				}
				return false;
			}
		}

		public static bool IsCloudEnabledForAccount => Internal.IsCloudEnabledForAccount();

		public static bool IsCloudEnabledForApp
		{
			get
			{
				return Internal.IsCloudEnabledForApp();
			}
			set
			{
				Internal.SetCloudEnabledForApp(value);
			}
		}

		public static int FileCount => Internal.GetFileCount();

		public static IEnumerable<string> Files
		{
			[IteratorStateMachine(typeof(<get_Files>d__27))]
			get
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <get_Files>d__27(-2);
			}
		}

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamRemoteStorage(server));
		}

		public unsafe static bool FileWrite(string filename, byte[] data)
		{
			fixed (byte* ptr = data)
			{
				return Internal.FileWrite(filename, (IntPtr)ptr, data.Length);
			}
		}

		public unsafe static byte[] FileRead(string filename)
		{
			int num = FileSize(filename);
			if (num <= 0)
			{
				return null;
			}
			byte[] array = new byte[num];
			fixed (byte* ptr = array)
			{
				Internal.FileRead(filename, (IntPtr)ptr, num);
				return array;
			}
		}

		public static bool FileExists(string filename)
		{
			return Internal.FileExists(filename);
		}

		public static bool FilePersisted(string filename)
		{
			return Internal.FilePersisted(filename);
		}

		public static DateTime FileTime(string filename)
		{
			return Epoch.ToDateTime(Internal.GetFileTimestamp(filename));
		}

		public static int FileSize(string filename)
		{
			return Internal.GetFileSize(filename);
		}

		public static bool FileForget(string filename)
		{
			return Internal.FileForget(filename);
		}

		public static bool FileDelete(string filename)
		{
			return Internal.FileDelete(filename);
		}
	}
	public class SteamScreenshots : SteamClientClass<SteamScreenshots>
	{
		internal static ISteamScreenshots Internal => SteamClientClass<SteamScreenshots>.Interface as ISteamScreenshots;

		public static bool Hooked
		{
			get
			{
				return Internal.IsScreenshotsHooked();
			}
			set
			{
				Internal.HookScreenshots(value);
			}
		}

		public static event Action OnScreenshotRequested;

		public static event Action<Screenshot> OnScreenshotReady;

		public static event Action<Result> OnScreenshotFailed;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamScreenshots(server));
			InstallEvents();
		}

		internal static void InstallEvents()
		{
			Dispatch.Install<ScreenshotRequested_t>(delegate
			{
				SteamScreenshots.OnScreenshotRequested?.Invoke();
			});
			Dispatch.Install(delegate(ScreenshotReady_t x)
			{
				if (x.Result != Result.OK)
				{
					SteamScreenshots.OnScreenshotFailed?.Invoke(x.Result);
				}
				else
				{
					SteamScreenshots.OnScreenshotReady?.Invoke(new Screenshot
					{
						Value = x.Local
					});
				}
			});
		}

		public unsafe static Screenshot? WriteScreenshot(byte[] data, int width, int height)
		{
			fixed (byte* ptr = data)
			{
				ScreenshotHandle value = Internal.WriteScreenshot((IntPtr)ptr, (uint)data.Length, width, height);
				if (value.Value == 0)
				{
					return null;
				}
				Screenshot value2 = default(Screenshot);
				value2.Value = value;
				return value2;
			}
		}

		public static Screenshot? AddScreenshot(string filename, string thumbnail, int width, int height)
		{
			ScreenshotHandle value = Internal.AddScreenshotToLibrary(filename, thumbnail, width, height);
			if (value.Value == 0)
			{
				return null;
			}
			Screenshot value2 = default(Screenshot);
			value2.Value = value;
			return value2;
		}

		public static void TriggerScreenshot()
		{
			Internal.TriggerScreenshot();
		}
	}
	public class SteamServer : SteamServerClass<SteamServer>
	{
		private static readonly List<SteamClass> openInterfaces = new List<SteamClass>();

		private static bool _dedicatedServer;

		private static int _maxplayers = 0;

		private static int _botcount = 0;

		private static string _mapname;

		private static string _modDir = "";

		private static string _product = "";

		private static string _gameDescription = "";

		private static string _serverName = "";

		private static bool _passworded;

		private static string _gametags = "";

		private static Dictionary<string, string> KeyValue = new Dictionary<string, string>();

		internal static ISteamGameServer Internal => SteamServerClass<SteamServer>.Interface as ISteamGameServer;

		public static bool IsValid
		{
			get
			{
				if (Internal != null)
				{
					return Internal.IsValid;
				}
				return false;
			}
		}

		public static bool DedicatedServer
		{
			get
			{
				return _dedicatedServer;
			}
			set
			{
				if (_dedicatedServer != value)
				{
					Internal.SetDedicatedServer(value);
					_dedicatedServer = value;
				}
			}
		}

		public static int MaxPlayers
		{
			get
			{
				return _maxplayers;
			}
			set
			{
				if (_maxplayers != value)
				{
					Internal.SetMaxPlayerCount(value);
					_maxplayers = value;
				}
			}
		}

		public static int BotCount
		{
			get
			{
				return _botcount;
			}
			set
			{
				if (_botcount != value)
				{
					Internal.SetBotPlayerCount(value);
					_botcount = value;
				}
			}
		}

		public static string MapName
		{
			get
			{
				return _mapname;
			}
			set
			{
				if (!(_mapname == value))
				{
					Internal.SetMapName(value);
					_mapname = value;
				}
			}
		}

		public static string ModDir
		{
			get
			{
				return _modDir;
			}
			internal set
			{
				if (!(_modDir == value))
				{
					Internal.SetModDir(value);
					_modDir = value;
				}
			}
		}

		public static string Product
		{
			get
			{
				return _product;
			}
			internal set
			{
				if (!(_product == value))
				{
					Internal.SetProduct(value);
					_product = value;
				}
			}
		}

		public static string GameDescription
		{
			get
			{
				return _gameDescription;
			}
			internal set
			{
				if (!(_gameDescription == value))
				{
					Internal.SetGameDescription(value);
					_gameDescription = value;
				}
			}
		}

		public static string ServerName
		{
			get
			{
				return _serverName;
			}
			set
			{
				if (!(_serverName == value))
				{
					Internal.SetServerName(value);
					_serverName = value;
				}
			}
		}

		public static bool Passworded
		{
			get
			{
				return _passworded;
			}
			set
			{
				if (_passworded != value)
				{
					Internal.SetPasswordProtected(value);
					_passworded = value;
				}
			}
		}

		public static string GameTags
		{
			get
			{
				return _gametags;
			}
			set
			{
				if (!(_gametags == value))
				{
					Internal.SetGameTags(value);
					_gametags = value;
				}
			}
		}

		public static bool LoggedOn => Internal.BLoggedOn();

		public static IPAddress PublicIp => Internal.GetPublicIP();

		public static bool AutomaticHeartbeats
		{
			set
			{
				Internal.EnableHeartbeats(value);
			}
		}

		public static int AutomaticHeartbeatRate
		{
			set
			{
				Internal.SetHeartbeatInterval(value);
			}
		}

		public static event Action<SteamId, SteamId, AuthResponse> OnValidateAuthTicketResponse;

		public static event Action OnSteamServersConnected;

		public static event Action<Result, bool> OnSteamServerConnectFailure;

		public static event Action<Result> OnSteamServersDisconnected;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamGameServer(server));
			InstallEvents();
		}

		internal static void InstallEvents()
		{
			Dispatch.Install(delegate(ValidateAuthTicketResponse_t x)
			{
				SteamServer.OnValidateAuthTicketResponse?.Invoke(x.SteamID, x.OwnerSteamID, x.AuthSessionResponse);
			}, server: true);
			Dispatch.Install<SteamServersConnected_t>(delegate
			{
				SteamServer.OnSteamServersConnected?.Invoke();
			}, server: true);
			Dispatch.Install(delegate(SteamServerConnectFailure_t x)
			{
				SteamServer.OnSteamServerConnectFailure?.Invoke(x.Result, x.StillRetrying);
			}, server: true);
			Dispatch.Install(delegate(SteamServersDisconnected_t x)
			{
				SteamServer.OnSteamServersDisconnected?.Invoke(x.Result);
			}, server: true);
		}

		public static void Init(AppId appid, SteamServerInit init, bool asyncCallbacks = true)
		{
			if (IsValid)
			{
				throw new Exception("Calling SteamServer.Init but is already initialized");
			}
			uint num = 0u;
			if (init.SteamPort == 0)
			{
				init = init.WithRandomSteamPort();
			}
			if (init.IpAddress != null)
			{
				num = init.IpAddress.IpToInt32();
			}
			Environment.SetEnvironmentVariable("SteamAppId", appid.ToString());
			Environment.SetEnvironmentVariable("SteamGameId", appid.ToString());
			int num2 = (init.Secure ? 3 : 2);
			if (!SteamInternal.GameServer_Init(num, init.SteamPort, init.GamePort, init.QueryPort, num2, init.VersionString))
			{
				throw new Exception($"InitGameServer returned false ({num},{init.SteamPort},{init.GamePort},{init.QueryPort},{num2},\"{init.VersionString}\")");
			}
			Dispatch.Init();
			Dispatch.ServerPipe = SteamGameServer.GetHSteamPipe();
			AddInterface<SteamServer>();
			AddInterface<SteamUtils>();
			AddInterface<SteamNetworking>();
			AddInterface<SteamServerStats>();
			AddInterface<SteamInventory>();
			AddInterface<SteamUGC>();
			AddInterface<SteamApps>();
			AddInterface<SteamNetworkingUtils>();
			AddInterface<SteamNetworkingSockets>();
			AutomaticHeartbeats = true;
			MaxPlayers = 32;
			BotCount = 0;
			Product = $"{appid.Value}";
			ModDir = init.ModDir;
			GameDescription = init.GameDescription;
			Passworded = false;
			DedicatedServer = init.DedicatedServer;
			if (asyncCallbacks)
			{
				Dispatch.LoopServerAsync();
			}
		}

		internal static void AddInterface<T>() where T : SteamClass, new()
		{
			T val = new T();
			val.InitializeInterface(server: true);
			openInterfaces.Add(val);
		}

		internal static void ShutdownInterfaces()
		{
			foreach (SteamClass openInterface in openInterfaces)
			{
				openInterface.DestroyInterface(server: true);
			}
			openInterfaces.Clear();
		}

		public static void Shutdown()
		{
			Dispatch.ShutdownServer();
			ShutdownInterfaces();
			SteamGameServer.Shutdown();
		}

		public static void RunCallbacks()
		{
			if (Dispatch.ServerPipe != 0)
			{
				Dispatch.Frame(Dispatch.ServerPipe);
			}
		}

		public static void LogOnAnonymous()
		{
			Internal.LogOnAnonymous();
			ForceHeartbeat();
		}

		public static void LogOff()
		{
			Internal.LogOff();
		}

		public static void ForceHeartbeat()
		{
			Internal.ForceHeartbeat();
		}

		public static void UpdatePlayer(SteamId steamid, string name, int score)
		{
			Internal.BUpdateUserData(steamid, name, (uint)score);
		}

		public static void SetKey(string Key, string Value)
		{
			if (KeyValue.ContainsKey(Key))
			{
				if (KeyValue[Key] == Value)
				{
					return;
				}
				KeyValue[Key] = Value;
			}
			else
			{
				KeyValue.Add(Key, Value);
			}
			Internal.SetKeyValue(Key, Value);
		}

		public static void ClearKeys()
		{
			KeyValue.Clear();
			Internal.ClearAllKeyValues();
		}

		public unsafe static bool BeginAuthSession(byte[] data, SteamId steamid)
		{
			fixed (byte* ptr = data)
			{
				if (Internal.BeginAuthSession((IntPtr)ptr, data.Length, steamid) == BeginAuthResult.OK)
				{
					return true;
				}
				return false;
			}
		}

		public static void EndSession(SteamId steamid)
		{
			Internal.EndAuthSession(steamid);
		}

		public unsafe static bool GetOutgoingPacket(out OutgoingPacket packet)
		{
			byte[] array = Helpers.TakeBuffer(32768);
			packet = default(OutgoingPacket);
			fixed (byte* ptr = array)
			{
				uint pNetAdr = 0u;
				ushort pPort = 0;
				int nextOutgoingPacket = Internal.GetNextOutgoingPacket((IntPtr)ptr, array.Length, ref pNetAdr, ref pPort);
				if (nextOutgoingPacket == 0)
				{
					return false;
				}
				packet.Size = nextOutgoingPacket;
				packet.Data = array;
				packet.Address = pNetAdr;
				packet.Port = pPort;
				return true;
			}
		}

		public unsafe static void HandleIncomingPacket(byte[] data, int size, uint address, ushort port)
		{
			fixed (byte* ptr = data)
			{
				HandleIncomingPacket((IntPtr)ptr, size, address, port);
			}
		}

		public static void HandleIncomingPacket(IntPtr ptr, int size, uint address, ushort port)
		{
			Internal.HandleIncomingPacket(ptr, size, address, port);
		}

		public static UserHasLicenseForAppResult UserHasLicenseForApp(SteamId steamid, AppId appid)
		{
			return Internal.UserHasLicenseForApp(steamid, appid);
		}
	}
	public class SteamServerStats : SteamServerClass<SteamServerStats>
	{
		internal static ISteamGameServerStats Internal => SteamServerClass<SteamServerStats>.Interface as ISteamGameServerStats;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamGameServerStats(server));
		}

		public static async Task<Result> RequestUserStatsAsync(SteamId steamid)
		{
			GSStatsReceived_t? gSStatsReceived_t = await Internal.RequestUserStats(steamid);
			if (!gSStatsReceived_t.HasValue)
			{
				return Result.Fail;
			}
			return gSStatsReceived_t.Value.Result;
		}

		public static bool SetInt(SteamId steamid, string name, int stat)
		{
			return Internal.SetUserStat(steamid, name, stat);
		}

		public static bool SetFloat(SteamId steamid, string name, float stat)
		{
			return Internal.SetUserStat(steamid, name, stat);
		}

		public static int GetInt(SteamId steamid, string name, int defaultValue = 0)
		{
			int pData = defaultValue;
			if (!Internal.GetUserStat(steamid, name, ref pData))
			{
				return defaultValue;
			}
			return pData;
		}

		public static float GetFloat(SteamId steamid, string name, float defaultValue = 0f)
		{
			float pData = defaultValue;
			if (!Internal.GetUserStat(steamid, name, ref pData))
			{
				return defaultValue;
			}
			return pData;
		}

		public static bool SetAchievement(SteamId steamid, string name)
		{
			return Internal.SetUserAchievement(steamid, name);
		}

		public static bool ClearAchievement(SteamId steamid, string name)
		{
			return Internal.ClearUserAchievement(steamid, name);
		}

		public static bool GetAchievement(SteamId steamid, string name)
		{
			bool pbAchieved = false;
			if (!Internal.GetUserAchievement(steamid, name, ref pbAchieved))
			{
				return false;
			}
			return pbAchieved;
		}

		public static async Task<Result> StoreUserStats(SteamId steamid)
		{
			GSStatsStored_t? gSStatsStored_t = await Internal.StoreUserStats(steamid);
			if (!gSStatsStored_t.HasValue)
			{
				return Result.Fail;
			}
			return gSStatsStored_t.Value.Result;
		}
	}
	public class SteamUGC : SteamSharedClass<SteamUGC>
	{
		internal static ISteamUGC Internal => SteamSharedClass<SteamUGC>.Interface as ISteamUGC;

		public static event Action<Result> OnDownloadItemResult;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamUGC(server));
			InstallEvents(server);
		}

		internal static void InstallEvents(bool server)
		{
			Dispatch.Install(delegate(DownloadItemResult_t x)
			{
				SteamUGC.OnDownloadItemResult?.Invoke(x.Result);
			}, server);
		}

		public static async Task<bool> DeleteFileAsync(PublishedFileId fileId)
		{
			DeleteItemResult_t? deleteItemResult_t = await Internal.DeleteItem(fileId);
			return deleteItemResult_t.HasValue && deleteItemResult_t.GetValueOrDefault().Result == Result.OK;
		}

		public static bool Download(PublishedFileId fileId, bool highPriority = false)
		{
			return Internal.DownloadItem(fileId, highPriority);
		}

		public static async Task<bool> DownloadAsync(PublishedFileId fileId, Action<float> progress = null, int milisecondsUpdateDelay = 60, CancellationToken ct = default(CancellationToken))
		{
			Item item = new Item(fileId);
			if (ct == default(CancellationToken))
			{
				ct = new CancellationTokenSource(TimeSpan.FromSeconds(60.0)).Token;
			}
			progress?.Invoke(0f);
			if (!Download(fileId, highPriority: true))
			{
				return item.IsInstalled;
			}
			Action<Result> onDownloadStarted = null;
			try
			{
				bool downloadStarted = false;
				onDownloadStarted = delegate
				{
					downloadStarted = true;
				};
				OnDownloadItemResult += onDownloadStarted;
				while (!downloadStarted && !ct.IsCancellationRequested)
				{
					await Task.Delay(milisecondsUpdateDelay);
				}
			}
			finally
			{
				OnDownloadItemResult -= onDownloadStarted;
			}
			progress?.Invoke(0.2f);
			await Task.Delay(milisecondsUpdateDelay);
			while (!ct.IsCancellationRequested)
			{
				progress?.Invoke(0.2f + item.DownloadAmount * 0.8f);
				if (!item.IsDownloading && item.IsInstalled)
				{
					break;
				}
				await Task.Delay(milisecondsUpdateDelay);
			}
			progress?.Invoke(1f);
			return item.IsInstalled;
		}

		public static async Task<Item?> QueryFileAsync(PublishedFileId fileId)
		{
			ResultPage? resultPage = await Query.All.WithFileId(fileId).GetPageAsync(1);
			if (!resultPage.HasValue || resultPage.Value.ResultCount != 1)
			{
				return null;
			}
			Item value = resultPage.Value.Entries.First();
			resultPage.Value.Dispose();
			return value;
		}

		public static async Task<bool> StartPlaytimeTracking(PublishedFileId fileId)
		{
			return (await Internal.StartPlaytimeTracking(new PublishedFileId[1] { fileId }, 1u)).Value.Result == Result.OK;
		}

		public static async Task<bool> StopPlaytimeTracking(PublishedFileId fileId)
		{
			return (await Internal.StopPlaytimeTracking(new PublishedFileId[1] { fileId }, 1u)).Value.Result == Result.OK;
		}

		public static async Task<bool> StopPlaytimeTrackingForAllItems()
		{
			return (await Internal.StopPlaytimeTrackingForAllItems()).Value.Result == Result.OK;
		}
	}
	public class SteamUser : SteamClientClass<SteamUser>
	{
		private static Dictionary<string, string> richPresence;

		private static bool _recordingVoice;

		private static byte[] readBuffer = new byte[131072];

		private static uint sampleRate = 48000u;

		internal static ISteamUser Internal => SteamClientClass<SteamUser>.Interface as ISteamUser;

		public static bool VoiceRecord
		{
			get
			{
				return _recordingVoice;
			}
			set
			{
				_recordingVoice = value;
				if (value)
				{
					Internal.StartVoiceRecording();
				}
				else
				{
					Internal.StopVoiceRecording();
				}
			}
		}

		public static bool HasVoiceData
		{
			get
			{
				uint pcbCompressed = 0u;
				uint pcbUncompressed_Deprecated = 0u;
				if (Internal.GetAvailableVoice(ref pcbCompressed, ref pcbUncompressed_Deprecated, 0u) != 0)
				{
					return false;
				}
				return pcbCompressed != 0;
			}
		}

		public static uint SampleRate
		{
			get
			{
				return sampleRate;
			}
			set
			{
				if (SampleRate < 11025)
				{
					throw new Exception("Sample Rate must be between 11025 and 48000");
				}
				if (SampleRate > 48000)
				{
					throw new Exception("Sample Rate must be between 11025 and 48000");
				}
				sampleRate = value;
			}
		}

		public static uint OptimalSampleRate => Internal.GetVoiceOptimalSampleRate();

		public static bool IsBehindNAT => Internal.BIsBehindNAT();

		public static int SteamLevel => Internal.GetPlayerSteamLevel();

		public static bool IsPhoneVerified => Internal.BIsPhoneVerified();

		public static bool IsTwoFactorEnabled => Internal.BIsTwoFactorEnabled();

		public static bool IsPhoneIdentifying => Internal.BIsPhoneIdentifying();

		public static bool IsPhoneRequiringVerification => Internal.BIsPhoneRequiringVerification();

		public static event Action OnSteamServersConnected;

		public static event Action OnSteamServerConnectFailure;

		public static event Action OnSteamServersDisconnected;

		public static event Action OnClientGameServerDeny;

		public static event Action OnLicensesUpdated;

		public static event Action<SteamId, SteamId, AuthResponse> OnValidateAuthTicketResponse;

		internal static event Action<GetAuthSessionTicketResponse_t> OnGetAuthSessionTicketResponse;

		public static event Action<AppId, ulong, bool> OnMicroTxnAuthorizationResponse;

		public static event Action<string> OnGameWebCallback;

		public static event Action<DurationControl> OnDurationControl;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamUser(server));
			InstallEvents();
			richPresence = new Dictionary<string, string>();
			SampleRate = OptimalSampleRate;
		}

		internal static void InstallEvents()
		{
			Dispatch.Install<SteamServersConnected_t>(delegate
			{
				SteamUser.OnSteamServersConnected?.Invoke();
			});
			Dispatch.Install<SteamServerConnectFailure_t>(delegate
			{
				SteamUser.OnSteamServerConnectFailure?.Invoke();
			});
			Dispatch.Install<SteamServersDisconnected_t>(delegate
			{
				SteamUser.OnSteamServersDisconnected?.Invoke();
			});
			Dispatch.Install<ClientGameServerDeny_t>(delegate
			{
				SteamUser.OnClientGameServerDeny?.Invoke();
			});
			Dispatch.Install<LicensesUpdated_t>(delegate
			{
				SteamUser.OnLicensesUpdated?.Invoke();
			});
			Dispatch.Install(delegate(ValidateAuthTicketResponse_t x)
			{
				SteamUser.OnValidateAuthTicketResponse?.Invoke(x.SteamID, x.OwnerSteamID, x.AuthSessionResponse);
			});
			Dispatch.Install(delegate(MicroTxnAuthorizationResponse_t x)
			{
				SteamUser.OnMicroTxnAuthorizationResponse?.Invoke(x.AppID, x.OrderID, x.Authorized != 0);
			});
			Dispatch.Install(delegate(GameWebCallback_t x)
			{
				SteamUser.OnGameWebCallback?.Invoke(x.URLUTF8());
			});
			Dispatch.Install(delegate(GetAuthSessionTicketResponse_t x)
			{
				SteamUser.OnGetAuthSessionTicketResponse?.Invoke(x);
			});
			Dispatch.Install(delegate(DurationControl_t x)
			{
				SteamUser.OnDurationControl?.Invoke(new DurationControl
				{
					_inner = x
				});
			});
		}

		public unsafe static int ReadVoiceData(Stream stream)
		{
			if (!HasVoiceData)
			{
				return 0;
			}
			uint nBytesWritten = 0u;
			uint nUncompressBytesWritten_Deprecated = 0u;
			fixed (byte* ptr = readBuffer)
			{
				if (Internal.GetVoice(bWantCompressed: true, (IntPtr)ptr, (uint)readBuffer.Length, ref nBytesWritten, bWantUncompressed_Deprecated: false, IntPtr.Zero, 0u, ref nUncompressBytesWritten_Deprecated, 0u) != 0)
				{
					return 0;
				}
			}
			if (nBytesWritten == 0)
			{
				return 0;
			}
			stream.Write(readBuffer, 0, (int)nBytesWritten);
			return (int)nBytesWritten;
		}

		public unsafe static byte[] ReadVoiceDataBytes()
		{
			if (!HasVoiceData)
			{
				return null;
			}
			uint nBytesWritten = 0u;
			uint nUncompressBytesWritten_Deprecated = 0u;
			fixed (byte* ptr = readBuffer)
			{
				if (Internal.GetVoice(bWantCompressed: true, (IntPtr)ptr, (uint)readBuffer.Length, ref nBytesWritten, bWantUncompressed_Deprecated: false, IntPtr.Zero, 0u, ref nUncompressBytesWritten_Deprecated, 0u) != 0)
				{
					return null;
				}
			}
			if (nBytesWritten == 0)
			{
				return null;
			}
			byte[] array = new byte[nBytesWritten];
			Array.Copy(readBuffer, 0L, array, 0L, nBytesWritten);
			return array;
		}

		public unsafe static int DecompressVoice(Stream input, int length, Stream output)
		{
			byte[] array = Helpers.TakeBuffer(length);
			byte[] array2 = Helpers.TakeBuffer(65536);
			using (MemoryStream destination = new MemoryStream(array))
			{
				input.CopyTo(destination);
			}
			uint nBytesWritten = 0u;
			fixed (byte* ptr = array)
			{
				fixed (byte* ptr2 = array2)
				{
					if (Internal.DecompressVoice((IntPtr)ptr, (uint)length, (IntPtr)ptr2, (uint)array2.Length, ref nBytesWritten, SampleRate) != 0)
					{
						return 0;
					}
				}
			}
			if (nBytesWritten == 0)
			{
				return 0;
			}
			output.Write(array2, 0, (int)nBytesWritten);
			return (int)nBytesWritten;
		}

		public unsafe static int DecompressVoice(byte[] from, Stream output)
		{
			byte[] array = Helpers.TakeBuffer(65536);
			uint nBytesWritten = 0u;
			fixed (byte* ptr = from)
			{
				fixed (byte* ptr2 = array)
				{
					if (Internal.DecompressVoice((IntPtr)ptr, (uint)from.Length, (IntPtr)ptr2, (uint)array.Length, ref nBytesWritten, SampleRate) != 0)
					{
						return 0;
					}
				}
			}
			if (nBytesWritten == 0)
			{
				return 0;
			}
			output.Write(array, 0, (int)nBytesWritten);
			return (int)nBytesWritten;
		}

		public unsafe static AuthTicket GetAuthSessionTicket()
		{
			byte[] array = Helpers.TakeBuffer(1024);
			fixed (byte* ptr = array)
			{
				uint pcbTicket = 0u;
				uint num = Internal.GetAuthSessionTicket((IntPtr)ptr, array.Length, ref pcbTicket);
				if (num == 0)
				{
					return null;
				}
				return new AuthTicket
				{
					Data = array.Take((int)pcbTicket).ToArray(),
					Handle = num
				};
			}
		}

		public static async Task<AuthTicket> GetAuthSessionTicketAsync(double timeoutSeconds = 10.0)
		{
			Result result = Result.Pending;
			AuthTicket ticket = null;
			Stopwatch stopwatch = Stopwatch.StartNew();
			OnGetAuthSessionTicketResponse += f;
			try
			{
				ticket = GetAuthSessionTicket();
				if (ticket == null)
				{
					return null;
				}
				while (result == Result.Pending)
				{
					await Task.Delay(10);
					if (stopwatch.Elapsed.TotalSeconds > timeoutSeconds)
					{
						ticket.Cancel();
						return null;
					}
				}
				if (result == Result.OK)
				{
					return ticket;
				}
				ticket.Cancel();
				return null;
			}
			finally
			{
				OnGetAuthSessionTicketResponse -= f;
			}
			void f(GetAuthSessionTicketResponse_t t)
			{
				if (t.AuthTicket == ticket.Handle)
				{
					result = t.Result;
				}
			}
		}

		public unsafe static BeginAuthResult BeginAuthSession(byte[] ticketData, SteamId steamid)
		{
			fixed (byte* ptr = ticketData)
			{
				return Internal.BeginAuthSession((IntPtr)ptr, ticketData.Length, steamid);
			}
		}

		public static void EndAuthSession(SteamId steamid)
		{
			Internal.EndAuthSession(steamid);
		}

		public static async Task<string> GetStoreAuthUrlAsync(string url)
		{
			StoreAuthURLResponse_t? storeAuthURLResponse_t = await Internal.RequestStoreAuthURL(url);
			if (!storeAuthURLResponse_t.HasValue)
			{
				return null;
			}
			return storeAuthURLResponse_t.Value.URLUTF8();
		}

		public static async Task<byte[]> RequestEncryptedAppTicketAsync(byte[] dataToInclude)
		{
			IntPtr dataPtr = Marshal.AllocHGlobal(dataToInclude.Length);
			Marshal.Copy(dataToInclude, 0, dataPtr, dataToInclude.Length);
			try
			{
				EncryptedAppTicketResponse_t? encryptedAppTicketResponse_t = await Internal.RequestEncryptedAppTicket(dataPtr, dataToInclude.Length);
				if (!encryptedAppTicketResponse_t.HasValue || encryptedAppTicketResponse_t.Value.Result != Result.OK)
				{
					return null;
				}
				IntPtr intPtr = Marshal.AllocHGlobal(1024);
				uint pcbTicket = 0u;
				byte[] array = null;
				if (Internal.GetEncryptedAppTicket(intPtr, 1024, ref pcbTicket))
				{
					array = new byte[pcbTicket];
					Marshal.Copy(intPtr, array, 0, (int)pcbTicket);
				}
				Marshal.FreeHGlobal(intPtr);
				return array;
			}
			finally
			{
				Marshal.FreeHGlobal(dataPtr);
			}
		}

		public static async Task<byte[]> RequestEncryptedAppTicketAsync()
		{
			EncryptedAppTicketResponse_t? encryptedAppTicketResponse_t = await Internal.RequestEncryptedAppTicket(IntPtr.Zero, 0);
			if (!encryptedAppTicketResponse_t.HasValue || encryptedAppTicketResponse_t.Value.Result != Result.OK)
			{
				return null;
			}
			IntPtr intPtr = Marshal.AllocHGlobal(1024);
			uint pcbTicket = 0u;
			byte[] array = null;
			if (Internal.GetEncryptedAppTicket(intPtr, 1024, ref pcbTicket))
			{
				array = new byte[pcbTicket];
				Marshal.Copy(intPtr, array, 0, (int)pcbTicket);
			}
			Marshal.FreeHGlobal(intPtr);
			return array;
		}

		public static async Task<DurationControl> GetDurationControl()
		{
			DurationControl_t? durationControl_t = await Internal.GetDurationControl();
			if (!durationControl_t.HasValue)
			{
				return default(DurationControl);
			}
			DurationControl result = default(DurationControl);
			result._inner = durationControl_t.Value;
			return result;
		}
	}
	public class SteamUserStats : SteamClientClass<SteamUserStats>
	{
		[CompilerGenerated]
		private sealed class <get_Achievements>d__24 : IEnumerable<Steamworks.Data.Achievement>, IEnumerable, IEnumerator<Steamworks.Data.Achievement>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private Steamworks.Data.Achievement <>2__current;

			private int <>l__initialThreadId;

			private int <i>5__2;

			Steamworks.Data.Achievement IEnumerator<Steamworks.Data.Achievement>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <get_Achievements>d__24(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < Internal.GetNumAchievements())
				{
					<>2__current = new Steamworks.Data.Achievement(Internal.GetAchievementName((uint)<i>5__2));
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<Steamworks.Data.Achievement> IEnumerable<Steamworks.Data.Achievement>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <get_Achievements>d__24(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Steamworks.Data.Achievement>)this).GetEnumerator();
			}
		}

		internal static ISteamUserStats Internal => SteamClientClass<SteamUserStats>.Interface as ISteamUserStats;

		public static bool StatsRecieved { get; internal set; }

		public static IEnumerable<Steamworks.Data.Achievement> Achievements
		{
			[IteratorStateMachine(typeof(<get_Achievements>d__24))]
			get
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <get_Achievements>d__24(-2);
			}
		}

		internal static event Action<string, int> OnAchievementIconFetched;

		public static event Action<SteamId, Result> OnUserStatsReceived;

		public static event Action<Result> OnUserStatsStored;

		public static event Action<Steamworks.Data.Achievement, int, int> OnAchievementProgress;

		public static event Action<SteamId> OnUserStatsUnloaded;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamUserStats(server));
			InstallEvents();
			RequestCurrentStats();
		}

		internal static void InstallEvents()
		{
			Dispatch.Install(delegate(UserStatsReceived_t x)
			{
				if (x.SteamIDUser == (ulong)SteamClient.SteamId)
				{
					StatsRecieved = true;
				}
				SteamUserStats.OnUserStatsReceived?.Invoke(x.SteamIDUser, x.Result);
			});
			Dispatch.Install(delegate(UserStatsStored_t x)
			{
				SteamUserStats.OnUserStatsStored?.Invoke(x.Result);
			});
			Dispatch.Install(delegate(UserAchievementStored_t x)
			{
				SteamUserStats.OnAchievementProgress?.Invoke(new Steamworks.Data.Achievement(x.AchievementNameUTF8()), (int)x.CurProgress, (int)x.MaxProgress);
			});
			Dispatch.Install(delegate(UserStatsUnloaded_t x)
			{
				SteamUserStats.OnUserStatsUnloaded?.Invoke(x.SteamIDUser);
			});
			Dispatch.Install(delegate(UserAchievementIconFetched_t x)
			{
				SteamUserStats.OnAchievementIconFetched?.Invoke(x.AchievementNameUTF8(), x.IconHandle);
			});
		}

		public static bool IndicateAchievementProgress(string achName, int curProg, int maxProg)
		{
			if (string.IsNullOrEmpty(achName))
			{
				throw new ArgumentNullException("Achievement string is null or empty");
			}
			if (curProg >= maxProg)
			{
				throw new ArgumentException($" Current progress [{curProg}] arguement toward achievement greater than or equal to max [{maxProg}]");
			}
			return Internal.IndicateAchievementProgress(achName, (uint)curProg, (uint)maxProg);
		}

		public static async Task<int> PlayerCountAsync()
		{
			NumberOfCurrentPlayers_t? numberOfCurrentPlayers_t = await Internal.GetNumberOfCurrentPlayers();
			if (!numberOfCurrentPlayers_t.HasValue || numberOfCurrentPlayers_t.Value.Success == 0)
			{
				return -1;
			}
			return numberOfCurrentPlayers_t.Value.CPlayers;
		}

		public static bool StoreStats()
		{
			return Internal.StoreStats();
		}

		public static bool RequestCurrentStats()
		{
			return Internal.RequestCurrentStats();
		}

		public static async Task<Result> RequestGlobalStatsAsync(int days)
		{
			GlobalStatsReceived_t? globalStatsReceived_t = await Internal.RequestGlobalStats(days);
			if (!globalStatsReceived_t.HasValue)
			{
				return Result.Fail;
			}
			return globalStatsReceived_t.Value.Result;
		}

		public static async Task<Leaderboard?> FindOrCreateLeaderboardAsync(string name, LeaderboardSort sort, LeaderboardDisplay display)
		{
			LeaderboardFindResult_t? leaderboardFindResult_t = await Internal.FindOrCreateLeaderboard(name, sort, display);
			if (!leaderboardFindResult_t.HasValue || leaderboardFindResult_t.Value.LeaderboardFound == 0)
			{
				return null;
			}
			Leaderboard value = default(Leaderboard);
			value.Id = leaderboardFindResult_t.Value.SteamLeaderboard;
			return value;
		}

		public static async Task<Leaderboard?> FindLeaderboardAsync(string name)
		{
			LeaderboardFindResult_t? leaderboardFindResult_t = await Internal.FindLeaderboard(name);
			if (!leaderboardFindResult_t.HasValue || leaderboardFindResult_t.Value.LeaderboardFound == 0)
			{
				return null;
			}
			Leaderboard value = default(Leaderboard);
			value.Id = leaderboardFindResult_t.Value.SteamLeaderboard;
			return value;
		}

		public static bool AddStat(string name, int amount = 1)
		{
			int statInt = GetStatInt(name);
			statInt += amount;
			return SetStat(name, statInt);
		}

		public static bool AddStat(string name, float amount = 1f)
		{
			float statFloat = GetStatFloat(name);
			statFloat += amount;
			return SetStat(name, statFloat);
		}

		public static bool SetStat(string name, int value)
		{
			return Internal.SetStat(name, value);
		}

		public static bool SetStat(string name, float value)
		{
			return Internal.SetStat(name, value);
		}

		public static int GetStatInt(string name)
		{
			int pData = 0;
			Internal.GetStat(name, ref pData);
			return pData;
		}

		public static float GetStatFloat(string name)
		{
			float pData = 0f;
			Internal.GetStat(name, ref pData);
			return pData;
		}

		public static bool ResetAll(bool includeAchievements)
		{
			return Internal.ResetAllStats(includeAchievements);
		}
	}
	public class SteamUtils : SteamSharedClass<SteamUtils>
	{
		private static NotificationPosition overlayNotificationPosition = NotificationPosition.BottomRight;

		internal static ISteamUtils Internal => SteamSharedClass<SteamUtils>.Interface as ISteamUtils;

		public static uint SecondsSinceAppActive => Internal.GetSecondsSinceAppActive();

		public static uint SecondsSinceComputerActive => Internal.GetSecondsSinceComputerActive();

		public static Universe ConnectedUniverse => Internal.GetConnectedUniverse();

		public static DateTime SteamServerTime => Epoch.ToDateTime(Internal.GetServerRealTime());

		public static string IpCountry => Internal.GetIPCountry();

		public static bool UsingBatteryPower => Internal.GetCurrentBatteryPower() != byte.MaxValue;

		public static float CurrentBatteryPower => Math.Min(Internal.GetCurrentBatteryPower() / 100, 1f);

		public static NotificationPosition OverlayNotificationPosition
		{
			get
			{
				return overlayNotificationPosition;
			}
			set
			{
				overlayNotificationPosition = value;
				Internal.SetOverlayNotificationPosition(value);
			}
		}

		public static bool IsOverlayEnabled => Internal.IsOverlayEnabled();

		public static bool DoesOverlayNeedPresent => Internal.BOverlayNeedsPresent();

		public static string SteamUILanguage => Internal.GetSteamUILanguage();

		public static bool IsSteamRunningInVR => Internal.IsSteamRunningInVR();

		public static bool IsSteamInBigPictureMode => Internal.IsSteamInBigPictureMode();

		public static bool VrHeadsetStreaming
		{
			get
			{
				return Internal.IsVRHeadsetStreamingEnabled();
			}
			set
			{
				Internal.SetVRHeadsetStreamingEnabled(value);
			}
		}

		public static bool IsSteamChinaLauncher => Internal.IsSteamChinaLauncher();

		public static event Action OnIpCountryChanged;

		public static event Action<int> OnLowBatteryPower;

		public static event Action OnSteamShutdown;

		public static event Action<bool> OnGamepadTextInputDismissed;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamUtils(server));
			InstallEvents(server);
		}

		internal static void InstallEvents(bool server)
		{
			Dispatch.Install<IPCountry_t>(delegate
			{
				SteamUtils.OnIpCountryChanged?.Invoke();
			}, server);
			Dispatch.Install(delegate(LowBatteryPower_t x)
			{
				SteamUtils.OnLowBatteryPower?.Invoke(x.MinutesBatteryLeft);
			}, server);
			Dispatch.Install<SteamShutdown_t>(delegate
			{
				SteamClosed();
			}, server);
			Dispatch.Install(delegate(GamepadTextInputDismissed_t x)
			{
				SteamUtils.OnGamepadTextInputDismissed?.Invoke(x.Submitted);
			}, server);
		}

		private static void SteamClosed()
		{
			SteamClient.Cleanup();
			SteamUtils.OnSteamShutdown?.Invoke();
		}

		public static bool GetImageSize(int image, out uint width, out uint height)
		{
			width = 0u;
			height = 0u;
			return Internal.GetImageSize(image, ref width, ref height);
		}

		public static Image? GetImage(int image)
		{
			switch (image)
			{
			case -1:
				return null;
			case 0:
				return null;
			default:
			{
				Image value = default(Image);
				if (!GetImageSize(image, out value.Width, out value.Height))
				{
					return null;
				}
				uint num = value.Width * value.Height * 4;
				byte[] array = Helpers.TakeBuffer((int)num);
				if (!Internal.GetImageRGBA(image, array, (int)num))
				{
					return null;
				}
				value.Data = new byte[num];
				Array.Copy(array, 0L, value.Data, 0L, num);
				return value;
			}
			}
		}

		public static async Task<CheckFileSignature> CheckFileSignatureAsync(string filename)
		{
			CheckFileSignature_t? checkFileSignature_t = await Internal.CheckFileSignature(filename);
			if (!checkFileSignature_t.HasValue)
			{
				throw new Exception("Something went wrong");
			}
			return checkFileSignature_t.Value.CheckFileSignature;
		}

		public static bool ShowGamepadTextInput(GamepadTextInputMode inputMode, GamepadTextInputLineMode lineInputMode, string description, int maxChars, string existingText = "")
		{
			return Internal.ShowGamepadTextInput(inputMode, lineInputMode, description, (uint)maxChars, existingText);
		}

		public static string GetEnteredGamepadText()
		{
			if (Internal.GetEnteredGamepadTextLength() == 0)
			{
				return string.Empty;
			}
			if (!Internal.GetEnteredGamepadTextInput(out var pchText))
			{
				return string.Empty;
			}
			return pchText;
		}

		public static void SetOverlayNotificationInset(int x, int y)
		{
			Internal.SetOverlayNotificationInset(x, y);
		}

		public static void StartVRDashboard()
		{
			Internal.StartVRDashboard();
		}

		internal static bool IsCallComplete(SteamAPICall_t call, out bool failed)
		{
			failed = false;
			return Internal.IsAPICallCompleted(call, ref failed);
		}
	}
	public class SteamVideo : SteamClientClass<SteamVideo>
	{
		internal static ISteamVideo Internal => SteamClientClass<SteamVideo>.Interface as ISteamVideo;

		public static bool IsBroadcasting
		{
			get
			{
				int pnNumViewers = 0;
				return Internal.IsBroadcasting(ref pnNumViewers);
			}
		}

		public static int NumViewers
		{
			get
			{
				int pnNumViewers = 0;
				if (!Internal.IsBroadcasting(ref pnNumViewers))
				{
					return 0;
				}
				return pnNumViewers;
			}
		}

		public static event Action OnBroadcastStarted;

		public static event Action<BroadcastUploadResult> OnBroadcastStopped;

		internal override void InitializeInterface(bool server)
		{
			SetInterface(server, new ISteamVideo(server));
			InstallEvents();
		}

		internal static void InstallEvents()
		{
			Dispatch.Install<BroadcastUploadStart_t>(delegate
			{
				SteamVideo.OnBroadcastStarted?.Invoke();
			});
			Dispatch.Install(delegate(BroadcastUploadStop_t x)
			{
				SteamVideo.OnBroadcastStopped?.Invoke(x.Result);
			});
		}
	}
	public struct AppId
	{
		public uint Value;

		public override string ToString()
		{
			return Value.ToString();
		}

		public static implicit operator AppId(uint value)
		{
			AppId result = default(AppId);
			result.Value = value;
			return result;
		}

		public static implicit operator AppId(int value)
		{
			AppId result = default(AppId);
			result.Value = (uint)value;
			return result;
		}

		public static implicit operator uint(AppId value)
		{
			return value.Value;
		}
	}
	public struct Controller
	{
		internal InputHandle_t Handle;

		public ulong Id => Handle.Value;

		public InputType InputType => SteamInput.Internal.GetInputTypeForHandle(Handle);

		public string ActionSet
		{
			set
			{
				SteamInput.Internal.ActivateActionSet(Handle, SteamInput.Internal.GetActionSetHandle(value));
			}
		}

		internal Controller(InputHandle_t inputHandle_t)
		{
			Handle = inputHandle_t;
		}

		public void DeactivateLayer(string layer)
		{
			SteamInput.Internal.DeactivateActionSetLayer(Handle, SteamInput.Internal.GetActionSetHandle(layer));
		}

		public void ActivateLayer(string layer)
		{
			SteamInput.Internal.ActivateActionSetLayer(Handle, SteamInput.Internal.GetActionSetHandle(layer));
		}

		public void ClearLayers()
		{
			SteamInput.Internal.DeactivateAllActionSetLayers(Handle);
		}

		public DigitalState GetDigitalState(string actionName)
		{
			return SteamInput.Internal.GetDigitalActionData(Handle, SteamInput.GetDigitalActionHandle(actionName));
		}

		public AnalogState GetAnalogState(string actionName)
		{
			return SteamInput.Internal.GetAnalogActionData(Handle, SteamInput.GetAnalogActionHandle(actionName));
		}

		public override string ToString()
		{
			return $"{InputType}.{Handle.Value}";
		}

		public static bool operator ==(Controller a, Controller b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(Controller a, Controller b)
		{
			return !(a == b);
		}

		public override bool Equals(object p)
		{
			return Equals((Controller)p);
		}

		public override int GetHashCode()
		{
			return Handle.GetHashCode();
		}

		public bool Equals(Controller p)
		{
			return p.Handle == Handle;
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct AnalogState
	{
		public InputSourceMode EMode;

		public float X;

		public float Y;

		internal byte BActive;

		public bool Active => BActive != 0;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	internal struct MotionState
	{
		public float RotQuatX;

		public float RotQuatY;

		public float RotQuatZ;

		public float RotQuatW;

		public float PosAccelX;

		public float PosAccelY;

		public float PosAccelZ;

		public float RotVelX;

		public float RotVelY;

		public float RotVelZ;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct DigitalState
	{
		[MarshalAs(UnmanagedType.I1)]
		internal byte BState;

		[MarshalAs(UnmanagedType.I1)]
		internal byte BActive;

		public bool Pressed => BState != 0;

		public bool Active => BActive != 0;
	}
	public struct Friend
	{
		public struct FriendGameInfo
		{
			internal ulong GameID;

			internal uint GameIP;

			internal ulong SteamIDLobby;

			public int ConnectionPort;

			public int QueryPort;

			public uint IpAddressRaw => GameIP;

			public IPAddress IpAddress => Utility.Int32ToIp(GameIP);

			public Lobby? Lobby
			{
				get
				{
					if (SteamIDLobby == 0L)
					{
						return null;
					}
					return new Lobby(SteamIDLobby);
				}
			}

			internal static FriendGameInfo From(FriendGameInfo_t i)
			{
				FriendGameInfo result = default(FriendGameInfo);
				result.GameID = i.GameID;
				result.GameIP = i.GameIP;
				result.ConnectionPort = i.GamePort;
				result.QueryPort = i.QueryPort;
				result.SteamIDLobby = i.SteamIDLobby;
				return result;
			}
		}

		[CompilerGenerated]
		private sealed class <get_NameHistory>d__27 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			public Friend <>4__this;

			public Friend <>3__<>4__this;

			private int <i>5__2;

			string IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <get_NameHistory>d__27(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < 32)
				{
					string friendPersonaNameHistory = SteamFriends.Internal.GetFriendPersonaNameHistory(<>4__this.Id, <i>5__2);
					if (!string.IsNullOrEmpty(friendPersonaNameHistory))
					{
						<>2__current = friendPersonaNameHistory;
						<>1__state = 1;
						return true;
					}
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				<get_NameHistory>d__27 <get_NameHistory>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<get_NameHistory>d__ = this;
				}
				else
				{
					<get_NameHistory>d__ = new <get_NameHistory>d__27(0);
				}
				<get_NameHistory>d__.<>4__this = <>3__<>4__this;
				return <get_NameHistory>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		public SteamId Id;

		public bool IsMe => (ulong)Id == (ulong)SteamClient.SteamId;

		public bool IsFriend => Relationship == Relationship.Friend;

		public bool IsBlocked => Relationship == Relationship.Blocked;

		public bool IsPlayingThisGame => GameInfo?.GameID == (uint)SteamClient.AppId;

		public bool IsOnline => State != FriendState.Offline;

		public bool IsAway => State == FriendState.Away;

		public bool IsBusy => State == FriendState.Busy;

		public bool IsSnoozing => State == FriendState.Snooze;

		public Relationship Relationship => SteamFriends.Internal.GetFriendRelationship(Id);

		public FriendState State => SteamFriends.Internal.GetFriendPersonaState(Id);

		public string Name => SteamFriends.Internal.GetFriendPersonaName(Id);

		public IEnumerable<string> NameHistory
		{
			[IteratorStateMachine(typeof(<get_NameHistory>d__27))]
			get
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <get_NameHistory>d__27(-2)
				{
					<>3__<>4__this = this
				};
			}
		}

		public int SteamLevel => SteamFriends.Internal.GetFriendSteamLevel(Id);

		public FriendGameInfo? GameInfo
		{
			get
			{
				FriendGameInfo_t pFriendGameInfo = default(FriendGameInfo_t);
				if (!SteamFriends.Internal.GetFriendGamePlayed(Id, ref pFriendGameInfo))
				{
					return null;
				}
				return FriendGameInfo.From(pFriendGameInfo);
			}
		}

		public Friend(SteamId steamid)
		{
			Id = steamid;
		}

		public override string ToString()
		{
			return Name + " (" + Id.ToString() + ")";
		}

		public async Task RequestInfoAsync()
		{
			await SteamFriends.CacheUserInformationAsync(Id, nameonly: true);
		}

		public bool IsIn(SteamId group_or_room)
		{
			return SteamFriends.Internal.IsUserInSource(Id, group_or_room);
		}

		public async Task<Image?> GetSmallAvatarAsync()
		{
			return await SteamFriends.GetSmallAvatarAsync(Id);
		}

		public async Task<Image?> GetMediumAvatarAsync()
		{
			return await SteamFriends.GetMediumAvatarAsync(Id);
		}

		public async Task<Image?> GetLargeAvatarAsync()
		{
			return await SteamFriends.GetLargeAvatarAsync(Id);
		}

		public string GetRichPresence(string key)
		{
			string friendRichPresence = SteamFriends.Internal.GetFriendRichPresence(Id, key);
			if (string.IsNullOrEmpty(friendRichPresence))
			{
				return null;
			}
			return friendRichPresence;
		}

		public bool InviteToGame(string Text)
		{
			return SteamFriends.Internal.InviteUserToGame(Id, Text);
		}

		public bool SendMessage(string message)
		{
			return SteamFriends.Internal.ReplyToFriendMessage(Id, message);
		}

		public async Task<bool> RequestUserStatsAsync()
		{
			UserStatsReceived_t? userStatsReceived_t = await SteamUserStats.Internal.RequestUserStats(Id);
			return userStatsReceived_t.HasValue && userStatsReceived_t.Value.Result == Result.OK;
		}

		public float GetStatFloat(string statName, float defult = 0f)
		{
			float pData = defult;
			if (!SteamUserStats.Internal.GetUserStat(Id, statName, ref pData))
			{
				return defult;
			}
			return pData;
		}

		public int GetStatInt(string statName, int defult = 0)
		{
			int pData = defult;
			if (!SteamUserStats.Internal.GetUserStat(Id, statName, ref pData))
			{
				return defult;
			}
			return pData;
		}

		public bool GetAchievement(string statName, bool defult = false)
		{
			bool pbAchieved = defult;
			if (!SteamUserStats.Internal.GetUserAchievement(Id, statName, ref pbAchieved))
			{
				return defult;
			}
			return pbAchieved;
		}

		public DateTime GetAchievementUnlockTime(string statName)
		{
			bool pbAchieved = false;
			uint punUnlockTime = 0u;
			if (!SteamUserStats.Internal.GetUserAchievementAndUnlockTime(Id, statName, ref pbAchieved, ref punUnlockTime) || !pbAchieved)
			{
				return DateTime.MinValue;
			}
			return Epoch.ToDateTime(punUnlockTime);
		}
	}
	public class InventoryDef : IEquatable<InventoryDef>
	{
		[CompilerGenerated]
		private sealed class <get_Properties>d__34 : IEnumerable<KeyValuePair<string, string>>, IEnumerable, IEnumerator<KeyValuePair<string, string>>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private KeyValuePair<string, string> <>2__current;

			private int <>l__initialThreadId;

			public InventoryDef <>4__this;

			private string[] <>7__wrap1;

			private int <>7__wrap2;

			KeyValuePair<string, string> IEnumerator<KeyValuePair<string, string>>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <get_Properties>d__34(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				InventoryDef inventoryDef = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					string[] array = inventoryDef.GetProperty(null).Split(',');
					<>7__wrap1 = array;
					<>7__wrap2 = 0;
					break;
				}
				case 1:
					<>1__state = -1;
					<>7__wrap2++;
					break;
				}
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					string text = <>7__wrap1[<>7__wrap2];
					<>2__current = new KeyValuePair<string, string>(text, inventoryDef.GetProperty(text));
					<>1__state = 1;
					return true;
				}
				<>7__wrap1 = null;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<KeyValuePair<string, string>> IEnumerable<KeyValuePair<string, string>>.GetEnumerator()
			{
				<get_Properties>d__34 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <get_Properties>d__34(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<KeyValuePair<string, string>>)this).GetEnumerator();
			}
		}

		internal InventoryDefId _id;

		internal Dictionary<string, string> _properties;

		private InventoryRecipe[] _recContaining;

		public int Id => _id.Value;

		public string Name => GetProperty("name");

		public string Description => GetProperty("description");

		public string IconUrl => GetProperty("icon_url");

		public string IconUrlLarge => GetProperty("icon_url_large");

		public string PriceCategory => GetProperty("price_category");

		public string Type => GetProperty("type");

		public bool IsGenerator => Type == "generator";

		public string ExchangeSchema => GetProperty("exchange");

		public bool Marketable => GetBoolProperty("marketable");

		public bool Tradable => GetBoolProperty("tradable");

		public DateTime Created => GetProperty<DateTime>("timestamp");

		public DateTime Modified => GetProperty<DateTime>("modified");

		public IEnumerable<KeyValuePair<string, string>> Properties
		{
			[IteratorStateMachine(typeof(<get_Properties>d__34))]
			get
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <get_Properties>d__34(-2)
				{
					<>4__this = this
				};
			}
		}

		public int LocalPrice
		{
			get
			{
				ulong pCurrentPrice = 0uL;
				ulong pBasePrice = 0uL;
				if (!SteamInventory.Internal.GetItemPrice(Id, ref pCurrentPrice, ref pBasePrice))
				{
					return 0;
				}
				return (int)pCurrentPrice;
			}
		}

		public string LocalPriceFormatted => Utility.FormatPrice(SteamInventory.Currency, (double)LocalPrice / 100.0);

		public int LocalBasePrice
		{
			get
			{
				ulong pCurrentPrice = 0uL;
				ulong pBasePrice = 0uL;
				if (!SteamInventory.Internal.GetItemPrice(Id, ref pCurrentPrice, ref pBasePrice))
				{
					return 0;
				}
				return (int)pBasePrice;
			}
		}

		public string LocalBasePriceFormatted => Utility.FormatPrice(SteamInventory.Currency, (double)LocalPrice / 100.0);

		public InventoryDef(InventoryDefId defId)
		{
			_id = defId;
		}

		public InventoryRecipe[] GetRecipes()
		{
			if (string.IsNullOrEmpty(ExchangeSchema))
			{
				return null;
			}
			return (from x in ExchangeSchema.Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries)
				select InventoryRecipe.FromString(x, this)).ToArray();
		}

		public string GetProperty(string name)
		{
			if (_properties != null && _properties.TryGetValue(name, out var value))
			{
				return value;
			}
			uint punValueBufferSizeOut = 32768u;
			if (!SteamInventory.Internal.GetItemDefinitionProperty(Id, name, out var pchValueBuffer, ref punValueBufferSizeOut))
			{
				return null;
			}
			if (name == null)
			{
				return pchValueBuffer;
			}
			if (_properties == null)
			{
				_properties = new Dictionary<string, string>();
			}
			_properties[name] = pchValueBuffer;
			return pchValueBuffer;
		}

		public bool GetBoolProperty(string name)
		{
			string property = GetProperty(name);
			if (property.Length == 0)
			{
				return false;
			}
			if (property[0] == '0' || property[0] == 'F' || property[0] == 'f')
			{
				return false;
			}
			return true;
		}

		public T GetProperty<T>(string name)
		{
			string property = GetProperty(name);
			if (string.IsNullOrEmpty(property))
			{
				return default(T);
			}
			try
			{
				return (T)Convert.ChangeType(property, typeof(T));
			}
			catch (Exception)
			{
				return default(T);
			}
		}

		public InventoryRecipe[] GetRecipesContainingThis()
		{
			if (_recContaining != null)
			{
				return _recContaining;
			}
			IEnumerable<InventoryRecipe> source = (from x in SteamInventory.Definitions
				select x.GetRecipes() into x
				where x != null
				select x).SelectMany((InventoryRecipe[] x) => x);
			_recContaining = source.Where((InventoryRecipe x) => x.ContainsIngredient(this)).ToArray();
			return _recContaining;
		}

		public static bool operator ==(InventoryDef a, InventoryDef b)
		{
			return a?.Equals(b) ?? ((object)b == null);
		}

		public static bool operator !=(InventoryDef a, InventoryDef b)
		{
			return !(a == b);
		}

		public override bool Equals(object p)
		{
			return Equals((InventoryDef)p);
		}

		public override int GetHashCode()
		{
			return Id.GetHashCode();
		}

		public bool Equals(InventoryDef p)
		{
			if (p == null)
			{
				return false;
			}
			return p.Id == Id;
		}
	}
	public struct InventoryItem : IEquatable<InventoryItem>
	{
		public struct Amount
		{
			public InventoryItem Item;

			public int Quantity;
		}

		internal InventoryItemId _id;

		internal InventoryDefId _def;

		internal SteamItemFlags _flags;

		internal ushort _quantity;

		internal Dictionary<string, string> _properties;

		public InventoryItemId Id => _id;

		public InventoryDefId DefId => _def;

		public int Quantity => _quantity;

		public InventoryDef Def => SteamInventory.FindDefinition(DefId);

		public Dictionary<string, string> Properties => _properties;

		public bool IsNoTrade => _flags.HasFlag(SteamItemFlags.NoTrade);

		public bool IsRemoved => _flags.HasFlag(SteamItemFlags.Removed);

		public bool IsConsumed => _flags.HasFlag(SteamItemFlags.Consumed);

		public DateTime Acquired
		{
			get
			{
				if (Properties == null)
				{
					return DateTime.UtcNow;
				}
				if (Properties.TryGetValue("acquired", out var value))
				{
					int year = int.Parse(value.Substring(0, 4));
					int month = int.Parse(value.Substring(4, 2));
					int day = int.Parse(value.Substring(6, 2));
					int hour = int.Parse(value.Substring(9, 2));
					int minute = int.Parse(value.Substring(11, 2));
					int second = int.Parse(value.Substring(13, 2));
					return new DateTime(year, month, day, hour, minute, second, DateTimeKind.Utc);
				}
				return DateTime.UtcNow;
			}
		}

		public string Origin
		{
			get
			{
				if (Properties == null)
				{
					return null;
				}
				if (Properties.TryGetValue("origin", out var value))
				{
					return value;
				}
				return null;
			}
		}

		public async Task<InventoryResult?> ConsumeAsync(int amount = 1)
		{
			SteamInventoryResult_t pResultHandle = Defines.k_SteamInventoryResultInvalid;
			if (!SteamInventory.Internal.ConsumeItem(ref pResultHandle, Id, (uint)amount))
			{
				return null;
			}
			return await InventoryResult.GetAsync(pResultHandle);
		}

		public async Task<InventoryResult?> SplitStackAsync(int quantity = 1)
		{
			SteamInventoryResult_t pResultHandle = Defines.k_SteamInventoryResultInvalid;
			if (!SteamInventory.Internal.TransferItemQuantity(ref pResultHandle, Id, (uint)quantity, ulong.MaxValue))
			{
				return null;
			}
			return await InventoryResult.GetAsync(pResultHandle);
		}

		public async Task<InventoryResult?> AddAsync(InventoryItem add, int quantity = 1)
		{
			SteamInventoryResult_t pResultHandle = Defines.k_SteamInventoryResultInvalid;
			if (!SteamInventory.Internal.TransferItemQuantity(ref pResultHandle, add.Id, (uint)quantity, Id))
			{
				return null;
			}
			return await InventoryResult.GetAsync(pResultHandle);
		}

		internal static InventoryItem From(SteamItemDetails_t details)
		{
			InventoryItem result = default(InventoryItem);
			result._id = details.ItemId;
			result._def = details.Definition;
			result._flags = (SteamItemFlags)details.Flags;
			result._quantity = details.Quantity;
			return result;
		}

		internal static Dictionary<string, string> GetProperties(SteamInventoryResult_t result, int index)
		{
			uint punValueBufferSizeOut = 32768u;
			if (!SteamInventory.Internal.GetResultItemProperty(result, (uint)index, null, out var pchValueBuffer, ref punValueBufferSizeOut))
			{
				return null;
			}
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			string[] array = pchValueBuffer.Split(',');
			foreach (string text in array)
			{
				punValueBufferSizeOut = 32768u;
				if (SteamInventory.Internal.GetResultItemProperty(result, (uint)index, text, out var pchValueBuffer2, ref punValueBufferSizeOut))
				{
					dictionary.Add(text, pchValueBuffer2);
				}
			}
			return dictionary;
		}

		public static bool operator ==(InventoryItem a, InventoryItem b)
		{
			return a._id == b._id;
		}

		public static bool operator !=(InventoryItem a, InventoryItem b)
		{
			return a._id != b._id;
		}

		public override bool Equals(object p)
		{
			return Equals((InventoryItem)p);
		}

		public override int GetHashCode()
		{
			return _id.GetHashCode();
		}

		public bool Equals(InventoryItem p)
		{
			return p._id == _id;
		}
	}
	public struct InventoryRecipe : IEquatable<InventoryRecipe>
	{
		public struct Ingredient
		{
			public int DefinitionId;

			public InventoryDef Definition;

			public int Count;

			internal static Ingredient FromString(string part)
			{
				Ingredient result = default(Ingredient);
				result.Count = 1;
				try
				{
					if (part.Contains("x"))
					{
						int num = part.IndexOf('x');
						int result2 = 0;
						if (int.TryParse(part.Substring(num + 1), out result2))
						{
							result.Count = result2;
						}
						part = part.Substring(0, num);
					}
					result.DefinitionId = int.Parse(part);
					result.Definition = SteamInventory.FindDefinition(result.DefinitionId);
					return result;
				}
				catch (Exception)
				{
					return result;
				}
			}
		}

		public InventoryDef Result;

		public Ingredient[] Ingredients;

		public string Source;

		internal static InventoryRecipe FromString(string part, InventoryDef Result)
		{
			InventoryRecipe inventoryRecipe = default(InventoryRecipe);
			inventoryRecipe.Result = Result;
			inventoryRecipe.Source = part;
			InventoryRecipe result = inventoryRecipe;
			string[] source = part.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			result.Ingredients = (from x in source
				select Ingredient.FromString(x) into x
				where x.DefinitionId != 0
				select x).ToArray();
			return result;
		}

		internal bool ContainsIngredient(InventoryDef inventoryDef)
		{
			return Ingredients.Any((Ingredient x) => x.DefinitionId == inventoryDef.Id);
		}

		public static bool operator ==(InventoryRecipe a, InventoryRecipe b)
		{
			return a.GetHashCode() == b.GetHashCode();
		}

		public static bool operator !=(InventoryRecipe a, InventoryRecipe b)
		{
			return a.GetHashCode() != b.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((InventoryRecipe)p);
		}

		public override int GetHashCode()
		{
			return Source.GetHashCode();
		}

		public bool Equals(InventoryRecipe p)
		{
			return p.GetHashCode() == GetHashCode();
		}
	}
	public struct InventoryResult : IDisposable
	{
		internal SteamInventoryResult_t _id;

		public bool Expired { get; internal set; }

		public int ItemCount
		{
			get
			{
				uint punOutItemsArraySize = 0u;
				if (!SteamInventory.Internal.GetResultItems(_id, null, ref punOutItemsArraySize))
				{
					return 0;
				}
				return (int)punOutItemsArraySize;
			}
		}

		internal InventoryResult(SteamInventoryResult_t id, bool expired)
		{
			_id = id;
			Expired = expired;
		}

		public bool BelongsTo(SteamId steamId)
		{
			return SteamInventory.Internal.CheckResultSteamID(_id, steamId);
		}

		public InventoryItem[] GetItems(bool includeProperties = false)
		{
			uint punOutItemsArraySize = (uint)ItemCount;
			if (punOutItemsArraySize == 0)
			{
				return null;
			}
			SteamItemDetails_t[] array = new SteamItemDetails_t[punOutItemsArraySize];
			if (!SteamInventory.Internal.GetResultItems(_id, array, ref punOutItemsArraySize))
			{
				return null;
			}
			InventoryItem[] array2 = new InventoryItem[punOutItemsArraySize];
			for (int i = 0; i < punOutItemsArraySize; i++)
			{
				InventoryItem inventoryItem = InventoryItem.From(array[i]);
				if (includeProperties)
				{
					inventoryItem._properties = InventoryItem.GetProperties(_id, i);
				}
				array2[i] = inventoryItem;
			}
			return array2;
		}

		public void Dispose()
		{
			if (_id.Value != -1)
			{
				SteamInventory.Internal.DestroyResult(_id);
			}
		}

		internal static async Task<InventoryResult?> GetAsync(SteamInventoryResult_t sresult)
		{
			Result _result = Result.Pending;
			while (true)
			{
				switch (_result)
				{
				case Result.Pending:
					_result = SteamInventory.Internal.GetResultStatus(sresult);
					await Task.Delay(10);
					break;
				default:
					return null;
				case Result.OK:
				case Result.Expired:
					return new InventoryResult(sresult, _result == Result.Expired);
				}
			}
		}

		public unsafe byte[] Serialize()
		{
			uint punOutBufferSize = 0u;
			if (!SteamInventory.Internal.SerializeResult(_id, IntPtr.Zero, ref punOutBufferSize))
			{
				return null;
			}
			byte[] array = new byte[punOutBufferSize];
			fixed (byte* ptr = array)
			{
				if (!SteamInventory.Internal.SerializeResult(_id, (IntPtr)ptr, ref punOutBufferSize))
				{
					return null;
				}
			}
			return array;
		}
	}
	public struct PartyBeacon
	{
		internal PartyBeaconID_t Id;

		private static ISteamParties Internal => SteamParties.Internal;

		public SteamId Owner
		{
			get
			{
				SteamId pSteamIDBeaconOwner = default(SteamId);
				SteamPartyBeaconLocation_t pLocation = default(SteamPartyBeaconLocation_t);
				Internal.GetBeaconDetails(Id, ref pSteamIDBeaconOwner, ref pLocation, out var _);
				return pSteamIDBeaconOwner;
			}
		}

		public string MetaData
		{
			get
			{
				SteamId pSteamIDBeaconOwner = default(SteamId);
				SteamPartyBeaconLocation_t pLocation = default(SteamPartyBeaconLocation_t);
				Internal.GetBeaconDetails(Id, ref pSteamIDBeaconOwner, ref pLocation, out var pchMetadata);
				return pchMetadata;
			}
		}

		public async Task<string> JoinAsync()
		{
			JoinPartyCallback_t? joinPartyCallback_t = await Internal.JoinParty(Id);
			if (!joinPartyCallback_t.HasValue || joinPartyCallback_t.Value.Result != Result.OK)
			{
				return null;
			}
			return joinPartyCallback_t.Value.ConnectStringUTF8();
		}

		public void OnReservationCompleted(SteamId steamid)
		{
			Internal.OnReservationCompleted(Id, steamid);
		}

		public void CancelReservation(SteamId steamid)
		{
			Internal.CancelReservation(Id, steamid);
		}

		public bool Destroy()
		{
			return Internal.DestroyBeacon(Id);
		}
	}
	public struct SteamServerInit
	{
		public IPAddress IpAddress;

		public ushort SteamPort;

		public ushort GamePort;

		public ushort QueryPort;

		public bool Secure;

		public string VersionString;

		public string ModDir;

		public string GameDescription;

		public bool DedicatedServer;

		public SteamServerInit(string modDir, string gameDesc)
		{
			DedicatedServer = true;
			ModDir = modDir;
			GameDescription = gameDesc;
			GamePort = 27015;
			QueryPort = 27016;
			Secure = true;
			VersionString = "1.0.0.0";
			IpAddress = null;
			SteamPort = 0;
		}

		public SteamServerInit WithRandomSteamPort()
		{
			SteamPort = (ushort)new Random().Next(10000, 60000);
			return this;
		}

		public SteamServerInit WithQueryShareGamePort()
		{
			QueryPort = ushort.MaxValue;
			return this;
		}
	}
	public struct SteamId
	{
		public ulong Value;

		public uint AccountId => (uint)(Value & 0xFFFFFFFFu);

		public bool IsValid => Value != 0;

		public static implicit operator SteamId(ulong value)
		{
			SteamId result = default(SteamId);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(SteamId value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}
	}
	internal static class Epoch
	{
		private static readonly DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

		public static int Current => (int)DateTime.UtcNow.Subtract(epoch).TotalSeconds;

		public static DateTime ToDateTime(decimal unixTime)
		{
			return epoch.AddSeconds((long)unixTime);
		}

		public static uint FromDateTime(DateTime dt)
		{
			return (uint)dt.Subtract(epoch).TotalSeconds;
		}
	}
	internal static class Helpers
	{
		public const int MaxStringSize = 32768;

		private static IntPtr[] MemoryPool;

		private static int MemoryPoolIndex;

		private static byte[][] BufferPool;

		private static int BufferPoolIndex;

		public unsafe static IntPtr TakeMemory()
		{
			if (MemoryPool == null)
			{
				MemoryPool = new IntPtr[5];
				for (int i = 0; i < MemoryPool.Length; i++)
				{
					MemoryPool[i] = Marshal.AllocHGlobal(32768);
				}
			}
			MemoryPoolIndex++;
			if (MemoryPoolIndex >= MemoryPool.Length)
			{
				MemoryPoolIndex = 0;
			}
			IntPtr intPtr = MemoryPool[MemoryPoolIndex];
			*(sbyte*)(void*)intPtr = 0;
			return intPtr;
		}

		public static byte[] TakeBuffer(int minSize)
		{
			if (BufferPool == null)
			{
				BufferPool = new byte[8][];
				for (int i = 0; i < BufferPool.Length; i++)
				{
					BufferPool[i] = new byte[131072];
				}
			}
			BufferPoolIndex++;
			if (BufferPoolIndex >= BufferPool.Length)
			{
				BufferPoolIndex = 0;
			}
			if (BufferPool[BufferPoolIndex].Length < minSize)
			{
				BufferPool[BufferPoolIndex] = new byte[minSize + 1024];
			}
			return BufferPool[BufferPoolIndex];
		}

		internal unsafe static string MemoryToString(IntPtr ptr)
		{
			int num = 0;
			for (num = 0; num < 32768 && ((byte*)(void*)ptr)[num] != 0; num++)
			{
			}
			if (num == 0)
			{
				return string.Empty;
			}
			return Encoding.UTF8.GetString((byte*)(void*)ptr, num);
		}
	}
	internal class MonoPInvokeCallbackAttribute : Attribute
	{
	}
	internal class PreserveAttribute : Attribute
	{
	}
	internal static class Platform
	{
		public const int StructPlatformPackSize = 8;

		public const string LibraryName = "steam_api64";

		public const CallingConvention CC = CallingConvention.Cdecl;

		public const int StructPackSize = 4;
	}
	internal static class SourceServerQuery
	{
		private static readonly byte[] A2S_SERVERQUERY_GETCHALLENGE = new byte[5] { 85, 255, 255, 255, 255 };

		private const byte A2S_RULES = 86;

		private static readonly Dictionary<IPEndPoint, Task<Dictionary<string, string>>> PendingQueries = new Dictionary<IPEndPoint, Task<Dictionary<string, string>>>();

		internal static Task<Dictionary<string, string>> GetRules(ServerInfo server)
		{
			IPEndPoint endpoint = new IPEndPoint(server.Address, server.QueryPort);
			lock (PendingQueries)
			{
				if (PendingQueries.TryGetValue(endpoint, out var value))
				{
					return value;
				}
				Task<Dictionary<string, string>> task = GetRulesImpl(endpoint).ContinueWith(delegate(Task<Dictionary<string, string>> t)
				{
					lock (PendingQueries)
					{
						PendingQueries.Remove(endpoint);
						return t;
					}
				}).Unwrap();
				PendingQueries.Add(endpoint, task);
				return task;
			}
		}

		private static async Task<Dictionary<string, string>> GetRulesImpl(IPEndPoint endpoint)
		{
			try
			{
				using UdpClient client = new UdpClient();
				client.Client.SendTimeout = 3000;
				client.Client.ReceiveTimeout = 3000;
				client.Connect(endpoint);
				return await GetRules(client);
			}
			catch (Exception)
			{
				return null;
			}
		}

		private static async Task<Dictionary<string, string>> GetRules(UdpClient client)
		{
			byte[] array = await GetChallengeData(client);
			array[0] = 86;
			await Send(client, array);
			byte[] buffer = await Receive(client);
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			using BinaryReader binaryReader = new BinaryReader(new MemoryStream(buffer));
			if (binaryReader.ReadByte() != 69)
			{
				throw new Exception("Invalid data received in response to A2S_RULES request");
			}
			ushort num = binaryReader.ReadUInt16();
			for (int i = 0; i < num; i++)
			{
				dictionary.Add(binaryReader.ReadNullTerminatedUTF8String(), binaryReader.ReadNullTerminatedUTF8String());
			}
			return dictionary;
		}

		private static async Task<byte[]> Receive(UdpClient client)
		{
			byte[][] packets = null;
			do
			{
				byte[] buffer = (await client.ReceiveAsync()).Buffer;
				using BinaryReader binaryReader = new BinaryReader(new MemoryStream(buffer));
				switch (binaryReader.ReadInt32())
				{
				case -1:
				{
					byte[] array2 = new byte[buffer.Length - binaryReader.BaseStream.Position];
					Buffer.BlockCopy(buffer, (int)binaryReader.BaseStream.Position, array2, 0, array2.Length);
					return array2;
				}
				case -2:
				{
					binaryReader.ReadInt32();
					byte b = binaryReader.ReadByte();
					byte b2 = binaryReader.ReadByte();
					binaryReader.ReadInt32();
					if (packets == null)
					{
						packets = new byte[b2][];
					}
					byte[] array = new byte[buffer.Length - binaryReader.BaseStream.Position];
					Buffer.BlockCopy(buffer, (int)binaryReader.BaseStream.Position, array, 0, array.Length);
					packets[b] = array;
					break;
				}
				default:
					throw new Exception("Invalid Header");
				}
			}
			while (packets.Any((byte[] p) => p == null));
			return Combine(packets);
		}

		private static async Task<byte[]> GetChallengeData(UdpClient client)
		{
			await Send(client, A2S_SERVERQUERY_GETCHALLENGE);
			byte[] obj = await Receive(client);
			if (obj[0] != 65)
			{
				throw new Exception("Invalid Challenge");
			}
			return obj;
		}

		private static async Task Send(UdpClient client, byte[] message)
		{
			byte[] array = new byte[message.Length + 4];
			array[0] = byte.MaxValue;
			array[1] = byte.MaxValue;
			array[2] = byte.MaxValue;
			array[3] = byte.MaxValue;
			Buffer.BlockCopy(message, 0, array, 4, message.Length);
			await client.SendAsync(array, message.Length + 4);
		}

		private static byte[] Combine(byte[][] arrays)
		{
			byte[] array = new byte[arrays.Sum((byte[] a) => a.Length)];
			int num = 0;
			foreach (byte[] array2 in arrays)
			{
				Buffer.BlockCopy(array2, 0, array, num, array2.Length);
				num += array2.Length;
			}
			return array;
		}
	}
	internal abstract class SteamInterface
	{
		public IntPtr Self;

		public IntPtr SelfGlobal;

		public IntPtr SelfServer;

		public IntPtr SelfClient;

		public bool IsValid => Self != IntPtr.Zero;

		public bool IsServer { get; private set; }

		public virtual IntPtr GetUserInterfacePointer()
		{
			return IntPtr.Zero;
		}

		public virtual IntPtr GetServerInterfacePointer()
		{
			return IntPtr.Zero;
		}

		public virtual IntPtr GetGlobalInterfacePointer()
		{
			return IntPtr.Zero;
		}

		internal void SetupInterface(bool gameServer)
		{
			if (Self != IntPtr.Zero)
			{
				return;
			}
			IsServer = gameServer;
			SelfGlobal = GetGlobalInterfacePointer();
			Self = SelfGlobal;
			if (!(Self != IntPtr.Zero))
			{
				if (gameServer)
				{
					SelfServer = GetServerInterfacePointer();
					Self = SelfServer;
				}
				else
				{
					SelfClient = GetUserInterfacePointer();
					Self = SelfClient;
				}
			}
		}

		internal void ShutdownInterface()
		{
			Self = IntPtr.Zero;
		}
	}
	public abstract class SteamClass
	{
		internal abstract void InitializeInterface(bool server);

		internal abstract void DestroyInterface(bool server);
	}
	public class SteamSharedClass<T> : SteamClass
	{
		internal static SteamInterface InterfaceClient;

		internal static SteamInterface InterfaceServer;

		internal static SteamInterface Interface => InterfaceClient ?? InterfaceServer;

		internal override void InitializeInterface(bool server)
		{
		}

		internal virtual void SetInterface(bool server, SteamInterface iface)
		{
			if (server)
			{
				InterfaceServer = iface;
			}
			if (!server)
			{
				InterfaceClient = iface;
			}
		}

		internal override void DestroyInterface(bool server)
		{
			if (!server)
			{
				InterfaceClient = null;
			}
			if (server)
			{
				InterfaceServer = null;
			}
		}
	}
	public class SteamClientClass<T> : SteamClass
	{
		internal static SteamInterface Interface;

		internal override void InitializeInterface(bool server)
		{
		}

		internal virtual void SetInterface(bool server, SteamInterface iface)
		{
			if (server)
			{
				throw new NotSupportedException();
			}
			Interface = iface;
		}

		internal override void DestroyInterface(bool server)
		{
			Interface = null;
		}
	}
	public class SteamServerClass<T> : SteamClass
	{
		internal static SteamInterface Interface;

		internal override void InitializeInterface(bool server)
		{
		}

		internal virtual void SetInterface(bool server, SteamInterface iface)
		{
			if (!server)
			{
				throw new NotSupportedException();
			}
			Interface = iface;
		}

		internal override void DestroyInterface(bool server)
		{
			Interface = null;
		}
	}
	internal class Utf8StringToNative : ICustomMarshaler
	{
		public unsafe IntPtr MarshalManagedToNative(object managedObj)
		{
			if (managedObj == null)
			{
				return IntPtr.Zero;
			}
			if (managedObj is string text)
			{
				fixed (char* chars = text)
				{
					int byteCount = Encoding.UTF8.GetByteCount(text);
					IntPtr intPtr = Marshal.AllocHGlobal(byteCount + 1);
					int bytes = Encoding.UTF8.GetBytes(chars, text.Length, (byte*)(void*)intPtr, byteCount + 1);
					((byte*)(void*)intPtr)[bytes] = 0;
					return intPtr;
				}
			}
			return IntPtr.Zero;
		}

		public object MarshalNativeToManaged(IntPtr pNativeData)
		{
			throw new NotImplementedException();
		}

		public void CleanUpNativeData(IntPtr pNativeData)
		{
			Marshal.FreeHGlobal(pNativeData);
		}

		public void CleanUpManagedData(object managedObj)
		{
			throw new NotImplementedException();
		}

		public int GetNativeDataSize()
		{
			return -1;
		}

		[Preserve]
		public static ICustomMarshaler GetInstance(string cookie)
		{
			return new Utf8StringToNative();
		}
	}
	internal struct Utf8StringPointer
	{
		internal IntPtr ptr;

		public unsafe static implicit operator string(Utf8StringPointer p)
		{
			if (p.ptr == IntPtr.Zero)
			{
				return null;
			}
			byte* ptr = (byte*)(void*)p.ptr;
			int i;
			for (i = 0; i < 67108864 && ptr[i] != 0; i++)
			{
			}
			return Encoding.UTF8.GetString(ptr, i);
		}
	}
	public static class Utility
	{
		private static readonly byte[] readBuffer = new byte[8192];

		internal static T ToType<T>(this IntPtr ptr)
		{
			if (ptr == IntPtr.Zero)
			{
				return default(T);
			}
			return (T)Marshal.PtrToStructure(ptr, typeof(T));
		}

		internal static object ToType(this IntPtr ptr, Type t)
		{
			if (ptr == IntPtr.Zero)
			{
				return null;
			}
			return Marshal.PtrToStructure(ptr, t);
		}

		internal static uint Swap(uint x)
		{
			return ((x & 0xFF) << 24) + ((x & 0xFF00) << 8) + ((x & 0xFF0000) >> 8) + ((x & 0xFF000000u) >> 24);
		}

		public static uint IpToInt32(this IPAddress ipAddress)
		{
			return Swap((uint)ipAddress.Address);
		}

		public static IPAddress Int32ToIp(uint ipAddress)
		{
			return new IPAddress(Swap(ipAddress));
		}

		public static string FormatPrice(string currency, double price)
		{
			string text = price.ToString("0.00");
			return currency switch
			{
				"AED" => text + "د.إ", 
				"ARS" => "$" + text + " ARS", 
				"AUD" => "A$" + text, 
				"BRL" => "R$" + text, 
				"CAD" => "C$" + text, 
				"CHF" => "Fr. " + text, 
				"CLP" => "$" + text + " CLP", 
				"CNY" => text + "元", 
				"COP" => "COL$ " + text, 
				"CRC" => "₡" + text, 
				"EUR" => "€" + text, 
				"SEK" => text + "kr", 
				"GBP" => "£" + text, 
				"HKD" => "HK$" + text, 
				"ILS" => "₪" + text, 
				"IDR" => "Rp" + text, 
				"INR" => "₹" + text, 
				"JPY" => "¥" + text, 
				"KRW" => "₩" + text, 
				"KWD" => "KD " + text, 
				"KZT" => text + "₸", 
				"MXN" => "Mex$" + text, 
				"MYR" => "RM " + text, 
				"NOK" => text + " kr", 
				"NZD" => "$" + text + " NZD", 
				"PEN" => "S/. " + text, 
				"PHP" => "₱" + text, 
				"PLN" => text + "zł", 
				"QAR" => "QR " + text, 
				"RUB" => text + "₽", 
				"SAR" => "SR " + text, 
				"SGD" => "S$" + text, 
				"THB" => "฿" + text, 
				"TRY" => "₺" + text, 
				"TWD" => "NT$ " + text, 
				"UAH" => "₴" + text, 
				"USD" => "$" + text, 
				"UYU" => "$U " + text, 
				"VND" => "₫" + text, 
				"ZAR" => "R " + text, 
				_ => text + " " + currency, 
			};
		}

		public static string ReadNullTerminatedUTF8String(this BinaryReader br)
		{
			lock (readBuffer)
			{
				int num = 0;
				byte b;
				while ((b = br.ReadByte()) != 0 && num < readBuffer.Length)
				{
					readBuffer[num] = b;
					num++;
				}
				return Encoding.UTF8.GetString(readBuffer, 0, num);
			}
		}
	}
}
namespace Steamworks.Ugc
{
	internal struct SteamParamStringArray : IDisposable
	{
		public SteamParamStringArray_t Value;

		private IntPtr[] NativeStrings;

		private IntPtr NativeArray;

		public static SteamParamStringArray From(string[] array)
		{
			SteamParamStringArray result = default(SteamParamStringArray);
			result.NativeStrings = new IntPtr[array.Length];
			for (int i = 0; i < result.NativeStrings.Length; i++)
			{
				result.NativeStrings[i] = Marshal.StringToHGlobalAnsi(array[i]);
			}
			int cb = Marshal.SizeOf(typeof(IntPtr)) * result.NativeStrings.Length;
			result.NativeArray = Marshal.AllocHGlobal(cb);
			Marshal.Copy(result.NativeStrings, 0, result.NativeArray, result.NativeStrings.Length);
			result.Value = new SteamParamStringArray_t
			{
				Strings = result.NativeArray,
				NumStrings = array.Length
			};
			return result;
		}

		public void Dispose()
		{
			IntPtr[] nativeStrings = NativeStrings;
			for (int i = 0; i < nativeStrings.Length; i++)
			{
				Marshal.FreeHGlobal(nativeStrings[i]);
			}
			Marshal.FreeHGlobal(NativeArray);
		}
	}
	public struct Editor
	{
		private PublishedFileId fileId;

		private bool creatingNew;

		private WorkshopFileType creatingType;

		private AppId consumerAppId;

		private string Title;

		private string Description;

		private string MetaData;

		private string ChangeLog;

		private string Language;

		private string PreviewFile;

		private DirectoryInfo ContentFolder;

		private RemoteStoragePublishedFileVisibility? Visibility;

		private List<string> Tags;

		private Dictionary<string, string> KeyValueTags;

		public static Editor NewCommunityFile => new Editor(WorkshopFileType.First);

		public static Editor NewMicrotransactionFile => new Editor(WorkshopFileType.Microtransaction);

		internal Editor(WorkshopFileType filetype)
		{
			this = default(Editor);
			creatingNew = true;
			creatingType = filetype;
		}

		public Editor(PublishedFileId fileId)
		{
			this = default(Editor);
			this.fileId = fileId;
		}

		public Editor ForAppId(AppId id)
		{
			consumerAppId = id;
			return this;
		}

		public Editor WithTitle(string t)
		{
			Title = t;
			return this;
		}

		public Editor WithDescription(string t)
		{
			Description = t;
			return this;
		}

		public Editor WithMetaData(string t)
		{
			MetaData = t;
			return this;
		}

		public Editor WithChangeLog(string t)
		{
			ChangeLog = t;
			return this;
		}

		public Editor InLanguage(string t)
		{
			Language = t;
			return this;
		}

		public Editor WithPreviewFile(string t)
		{
			PreviewFile = t;
			return this;
		}

		public Editor WithContent(DirectoryInfo t)
		{
			ContentFolder = t;
			return this;
		}

		public Editor WithContent(string folderName)
		{
			return WithContent(new DirectoryInfo(folderName));
		}

		public Editor WithPublicVisibility()
		{
			Visibility = RemoteStoragePublishedFileVisibility.Public;
			return this;
		}

		public Editor WithFriendsOnlyVisibility()
		{
			Visibility = RemoteStoragePublishedFileVisibility.FriendsOnly;
			return this;
		}

		public Editor WithPrivateVisibility()
		{
			Visibility = RemoteStoragePublishedFileVisibility.Private;
			return this;
		}

		public Editor WithTag(string tag)
		{
			if (Tags == null)
			{
				Tags = new List<string>();
			}
			Tags.Add(tag);
			return this;
		}

		public Editor AddKeyValueTag(string key, string value)
		{
			if (KeyValueTags == null)
			{
				KeyValueTags = new Dictionary<string, string>();
			}
			KeyValueTags.Add(key, value);
			return this;
		}

		public async Task<PublishResult> SubmitAsync(IProgress<float> progress = null)
		{
			PublishResult result = default(PublishResult);
			progress?.Report(0f);
			if ((uint)consumerAppId == 0)
			{
				consumerAppId = SteamClient.AppId;
			}
			if (creatingNew)
			{
				result.Result = Result.Fail;
				CreateItemResult_t? createItemResult_t = await SteamUGC.Internal.CreateItem(consumerAppId, creatingType);
				if (!createItemResult_t.HasValue)
				{
					return result;
				}
				result.Result = createItemResult_t.Value.Result;
				if (result.Result != Result.OK)
				{
					return result;
				}
				fileId = createItemResult_t.Value.PublishedFileId;
				result.NeedsWorkshopAgreement = createItemResult_t.Value.UserNeedsToAcceptWorkshopLegalAgreement;
				result.FileId = fileId;
			}
			result.FileId = fileId;
			UGCUpdateHandle_t handle = SteamUGC.Internal.StartItemUpdate(consumerAppId, fileId);
			if (handle == ulong.MaxValue)
			{
				return result;
			}
			if (Title != null)
			{
				SteamUGC.Internal.SetItemTitle(handle, Title);
			}
			if (Description != null)
			{
				SteamUGC.Internal.SetItemDescription(handle, Description);
			}
			if (MetaData != null)
			{
				SteamUGC.Internal.SetItemMetadata(handle, MetaData);
			}
			if (Language != null)
			{
				SteamUGC.Internal.SetItemUpdateLanguage(handle, Language);
			}
			if (ContentFolder != null)
			{
				SteamUGC.Internal.SetItemContent(handle, ContentFolder.FullName);
			}
			if (PreviewFile != null)
			{
				SteamUGC.Internal.SetItemPreview(handle, PreviewFile);
			}
			if (Visibility.HasValue)
			{
				SteamUGC.Internal.SetItemVisibility(handle, Visibility.Value);
			}
			if (Tags != null && Tags.Count > 0)
			{
				SteamParamStringArray steamParamStringArray = SteamParamStringArray.From(Tags.ToArray());
				try
				{
					SteamParamStringArray_t pTags = steamParamStringArray.Value;
					SteamUGC.Internal.SetItemTags(handle, ref pTags);
				}
				finally
				{
					((IDisposable)steamParamStringArray).Dispose();
				}
			}
			if (KeyValueTags != null && KeyValueTags.Count > 0)
			{
				foreach (KeyValuePair<string, string> keyValueTag in KeyValueTags)
				{
					SteamUGC.Internal.AddItemKeyValueTag(handle, keyValueTag.Key, keyValueTag.Value);
				}
			}
			result.Result = Result.Fail;
			if (ChangeLog == null)
			{
				ChangeLog = "";
			}
			CallResult<SubmitItemUpdateResult_t> updating = SteamUGC.Internal.SubmitItemUpdate(handle, ChangeLog);
			while (!updating.IsCompleted)
			{
				if (progress != null)
				{
					ulong punBytesTotal = 0uL;
					ulong punBytesProcessed = 0uL;
					switch (SteamUGC.Internal.GetItemUpdateProgress(handle, ref punBytesProcessed, ref punBytesTotal))
					{
					case ItemUpdateStatus.PreparingConfig:
						progress?.Report(0.1f);
						break;
					case ItemUpdateStatus.PreparingContent:
						progress?.Report(0.2f);
						break;
					case ItemUpdateStatus.UploadingContent:
					{
						float num = ((punBytesTotal != 0) ? ((float)punBytesProcessed / (float)punBytesTotal) : 0f);
						progress?.Report(0.2f + num * 0.7f);
						break;
					}
					case ItemUpdateStatus.UploadingPreviewFile:
						progress?.Report(0.8f);
						break;
					case ItemUpdateStatus.CommittingChanges:
						progress?.Report(1f);
						break;
					}
				}
				await Task.Delay(16);
			}
			progress?.Report(1f);
			SubmitItemUpdateResult_t? result2 = updating.GetResult();
			if (!result2.HasValue)
			{
				return result;
			}
			result.Result = result2.Value.Result;
			if (result.Result != Result.OK)
			{
				return result;
			}
			result.NeedsWorkshopAgreement = result2.Value.UserNeedsToAcceptWorkshopLegalAgreement;
			result.FileId = fileId;
			return result;
		}
	}
	public struct PublishResult
	{
		public Result Result;

		public PublishedFileId FileId;

		public bool NeedsWorkshopAgreement;

		public bool Success => Result == Result.OK;
	}
	public struct Item
	{
		internal SteamUGCDetails_t details;

		internal PublishedFileId _id;

		public PublishedFileId Id => _id;

		public string Title { get; internal set; }

		public string Description { get; internal set; }

		public string[] Tags { get; internal set; }

		public AppId CreatorApp => details.CreatorAppID;

		public AppId ConsumerApp => details.ConsumerAppID;

		public Friend Owner => new Friend(details.SteamIDOwner);

		public float Score => details.Score;

		public DateTime Created => Epoch.ToDateTime(details.TimeCreated);

		public DateTime Updated => Epoch.ToDateTime(details.TimeUpdated);

		public bool IsPublic => details.Visibility == RemoteStoragePublishedFileVisibility.Public;

		public bool IsFriendsOnly => details.Visibility == RemoteStoragePublishedFileVisibility.FriendsOnly;

		public bool IsPrivate => details.Visibility == RemoteStoragePublishedFileVisibility.Private;

		public bool IsBanned => details.Banned;

		public bool IsAcceptedForUse => details.AcceptedForUse;

		public uint VotesUp => details.VotesUp;

		public uint VotesDown => details.VotesDown;

		public bool IsInstalled => (State & ItemState.Installed) == ItemState.Installed;

		public bool IsDownloading => (State & ItemState.Downloading) == ItemState.Downloading;

		public bool IsDownloadPending => (State & ItemState.DownloadPending) == ItemState.DownloadPending;

		public bool IsSubscribed => (State & ItemState.Subscribed) == ItemState.Subscribed;

		public bool NeedsUpdate => (State & ItemState.NeedsUpdate) == ItemState.NeedsUpdate;

		public string Directory
		{
			get
			{
				ulong punSizeOnDisk = 0uL;
				uint punTimeStamp = 0u;
				if (!SteamUGC.Internal.GetItemInstallInfo(Id, ref punSizeOnDisk, out var pchFolder, ref punTimeStamp))
				{
					return null;
				}
				return pchFolder;
			}
		}

		public long DownloadBytesTotal
		{
			get
			{
				if (!NeedsUpdate)
				{
					return SizeBytes;
				}
				ulong punBytesDownloaded = 0uL;
				ulong punBytesTotal = 0uL;
				if (SteamUGC.Internal.GetItemDownloadInfo(Id, ref punBytesDownloaded, ref punBytesTotal))
				{
					return (long)punBytesTotal;
				}
				return -1L;
			}
		}

		public long DownloadBytesDownloaded
		{
			get
			{
				if (!NeedsUpdate)
				{
					return SizeBytes;
				}
				ulong punBytesDownloaded = 0uL;
				ulong punBytesTotal = 0uL;
				if (SteamUGC.Internal.GetItemDownloadInfo(Id, ref punBytesDownloaded, ref punBytesTotal))
				{
					return (long)punBytesDownloaded;
				}
				return -1L;
			}
		}

		public long SizeBytes
		{
			get
			{
				if (NeedsUpdate)
				{
					return DownloadBytesDownloaded;
				}
				ulong punSizeOnDisk = 0uL;
				uint punTimeStamp = 0u;
				if (!SteamUGC.Internal.GetItemInstallInfo(Id, ref punSizeOnDisk, out var _, ref punTimeStamp))
				{
					return 0L;
				}
				return (long)punSizeOnDisk;
			}
		}

		public float DownloadAmount
		{
			get
			{
				if (!IsDownloading)
				{
					return 1f;
				}
				ulong punBytesDownloaded = 0uL;
				ulong punBytesTotal = 0uL;
				if (SteamUGC.Internal.GetItemDownloadInfo(Id, ref punBytesDownloaded, ref punBytesTotal) && punBytesTotal != 0)
				{
					return (float)((double)punBytesDownloaded / (double)punBytesTotal);
				}
				if (NeedsUpdate || !IsInstalled || IsDownloading)
				{
					return 0f;
				}
				return 1f;
			}
		}

		private ItemState State => (ItemState)SteamUGC.Internal.GetItemState(Id);

		public string Url => $"http://steamcommunity.com/sharedfiles/filedetails/?source=Facepunch.Steamworks&id={Id}";

		public string ChangelogUrl => $"http://steamcommunity.com/sharedfiles/filedetails/changelog/{Id}";

		public string CommentsUrl => $"http://steamcommunity.com/sharedfiles/filedetails/comments/{Id}";

		public string DiscussUrl => $"http://steamcommunity.com/sharedfiles/filedetails/discussions/{Id}";

		public string StatsUrl => $"http://steamcommunity.com/sharedfiles/filedetails/stats/{Id}";

		public ulong NumSubscriptions { get; internal set; }

		public ulong NumFavorites { get; internal set; }

		public ulong NumFollowers { get; internal set; }

		public ulong NumUniqueSubscriptions { get; internal set; }

		public ulong NumUniqueFavorites { get; internal set; }

		public ulong NumUniqueFollowers { get; internal set; }

		public ulong NumUniqueWebsiteViews { get; internal set; }

		public ulong ReportScore { get; internal set; }

		public ulong NumSecondsPlayed { get; internal set; }

		public ulong NumPlaytimeSessions { get; internal set; }

		public ulong NumComments { get; internal set; }

		public ulong NumSecondsPlayedDuringTimePeriod { get; internal set; }

		public ulong NumPlaytimeSessionsDuringTimePeriod { get; internal set; }

		public string PreviewImageUrl { get; internal set; }

		public Result Result => details.Result;

		public Item(PublishedFileId id)
		{
			this = default(Item);
			_id = id;
		}

		public bool Download(bool highPriority = false)
		{
			return SteamUGC.Download(Id, highPriority);
		}

		public static async Task<Item?> GetAsync(PublishedFileId id, int maxageseconds = 1800)
		{
			SteamUGCRequestUGCDetailsResult_t? steamUGCRequestUGCDetailsResult_t = await SteamUGC.Internal.RequestUGCDetails(id, (uint)maxageseconds);
			if (!steamUGCRequestUGCDetailsResult_t.HasValue)
			{
				return null;
			}
			return From(steamUGCRequestUGCDetailsResult_t.Value.Details);
		}

		internal static Item From(SteamUGCDetails_t details)
		{
			Item result = default(Item);
			result._id = details.PublishedFileId;
			result.details = details;
			result.Title = details.TitleUTF8();
			result.Description = details.DescriptionUTF8();
			result.Tags = details.TagsUTF8().ToLower().Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			return result;
		}

		public bool HasTag(string find)
		{
			if (Tags.Length == 0)
			{
				return false;
			}
			return Tags.Contains<string>(find, StringComparer.OrdinalIgnoreCase);
		}

		public async Task<bool> Subscribe()
		{
			RemoteStorageSubscribePublishedFileResult_t? remoteStorageSubscribePublishedFileResult_t = await SteamUGC.Internal.SubscribeItem(_id);
			return remoteStorageSubscribePublishedFileResult_t.HasValue && remoteStorageSubscribePublishedFileResult_t.GetValueOrDefault().Result == Result.OK;
		}

		public async Task<bool> DownloadAsync(Action<float> progress = null, int milisecondsUpdateDelay = 60, CancellationToken ct = default(CancellationToken))
		{
			return await SteamUGC.DownloadAsync(Id, progress, milisecondsUpdateDelay, ct);
		}

		public async Task<bool> Unsubscribe()
		{
			RemoteStorageUnsubscribePublishedFileResult_t? remoteStorageUnsubscribePublishedFileResult_t = await SteamUGC.Internal.UnsubscribeItem(_id);
			return remoteStorageUnsubscribePublishedFileResult_t.HasValue && remoteStorageUnsubscribePublishedFileResult_t.GetValueOrDefault().Result == Result.OK;
		}

		public async Task<bool> AddFavorite()
		{
			UserFavoriteItemsListChanged_t? userFavoriteItemsListChanged_t = await SteamUGC.Internal.AddItemToFavorites(details.ConsumerAppID, _id);
			return userFavoriteItemsListChanged_t.HasValue && userFavoriteItemsListChanged_t.GetValueOrDefault().Result == Result.OK;
		}

		public async Task<bool> RemoveFavorite()
		{
			UserFavoriteItemsListChanged_t? userFavoriteItemsListChanged_t = await SteamUGC.Internal.RemoveItemFromFavorites(details.ConsumerAppID, _id);
			return userFavoriteItemsListChanged_t.HasValue && userFavoriteItemsListChanged_t.GetValueOrDefault().Result == Result.OK;
		}

		public async Task<Result?> Vote(bool up)
		{
			return (await SteamUGC.Internal.SetUserItemVote(Id, up))?.Result;
		}

		public async Task<UserItemVote?> GetUserVote()
		{
			GetUserItemVoteResult_t? getUserItemVoteResult_t = await SteamUGC.Internal.GetUserItemVote(_id);
			if (!getUserItemVoteResult_t.HasValue)
			{
				return null;
			}
			return UserItemVote.From(getUserItemVoteResult_t.Value);
		}

		public Editor Edit()
		{
			return new Editor(Id);
		}
	}
	public struct Query
	{
		private UgcType matchingType;

		private UGCQuery queryType;

		private AppId consumerApp;

		private AppId creatorApp;

		private string searchText;

		private SteamId? steamid;

		private UserUGCList userType;

		private UserUGCListSortOrder userSort;

		private PublishedFileId[] Files;

		private int? maxCacheAge;

		private string language;

		private int? trendDays;

		private List<string> requiredTags;

		private bool? matchAnyTag;

		private List<string> excludedTags;

		private Dictionary<string, string> requiredKv;

		private bool? WantsReturnOnlyIDs;

		private bool? WantsReturnKeyValueTags;

		private bool? WantsReturnLongDescription;

		private bool? WantsReturnMetadata;

		private bool? WantsReturnChildren;

		private bool? WantsReturnAdditionalPreviews;

		private bool? WantsReturnTotalOnly;

		private uint? WantsReturnPlaytimeStats;

		public static Query All => new Query(UgcType.All);

		public static Query Items => new Query(UgcType.Items);

		public static Query ItemsMtx => new Query(UgcType.Items_Mtx);

		public static Query ItemsReadyToUse => new Query(UgcType.Items_ReadyToUse);

		public static Query Collections => new Query(UgcType.Collections);

		public static Query Artwork => new Query(UgcType.Artwork);

		public static Query Videos => new Query(UgcType.Videos);

		public static Query Screenshots => new Query(UgcType.Screenshots);

		public static Query AllGuides => new Query(UgcType.AllGuides);

		public static Query WebGuides => new Query(UgcType.WebGuides);

		public static Query IntegratedGuides => new Query(UgcType.IntegratedGuides);

		public static Query UsableInGame => new Query(UgcType.UsableInGame);

		public static Query ControllerBindings => new Query(UgcType.ControllerBindings);

		public static Query GameManagedItems => new Query(UgcType.GameManagedItems);

		public Query(UgcType type)
		{
			this = default(Query);
			matchingType = type;
		}

		public Query RankedByVote()
		{
			queryType = UGCQuery.RankedByVote;
			return this;
		}

		public Query RankedByPublicationDate()
		{
			queryType = UGCQuery.RankedByPublicationDate;
			return this;
		}

		public Query RankedByAcceptanceDate()
		{
			queryType = UGCQuery.AcceptedForGameRankedByAcceptanceDate;
			return this;
		}

		public Query RankedByTrend()
		{
			queryType = UGCQuery.RankedByTrend;
			return this;
		}

		public Query FavoritedByFriends()
		{
			queryType = UGCQuery.FavoritedByFriendsRankedByPublicationDate;
			return this;
		}

		public Query CreatedByFriends()
		{
			queryType = UGCQuery.CreatedByFriendsRankedByPublicationDate;
			return this;
		}

		public Query RankedByNumTimesReported()
		{
			queryType = UGCQuery.RankedByNumTimesReported;
			return this;
		}

		public Query CreatedByFollowedUsers()
		{
			queryType = UGCQuery.CreatedByFollowedUsersRankedByPublicationDate;
			return this;
		}

		public Query NotYetRated()
		{
			queryType = UGCQuery.NotYetRated;
			return this;
		}

		public Query RankedByTotalVotesAsc()
		{
			queryType = UGCQuery.RankedByTotalVotesAsc;
			return this;
		}

		public Query RankedByVotesUp()
		{
			queryType = UGCQuery.RankedByVotesUp;
			return this;
		}

		public Query RankedByTextSearch()
		{
			queryType = UGCQuery.RankedByTextSearch;
			return this;
		}

		public Query RankedByTotalUniqueSubscriptions()
		{
			queryType = UGCQuery.RankedByTotalUniqueSubscriptions;
			return this;
		}

		public Query RankedByPlaytimeTrend()
		{
			queryType = UGCQuery.RankedByPlaytimeTrend;
			return this;
		}

		public Query RankedByTotalPlaytime()
		{
			queryType = UGCQuery.RankedByTotalPlaytime;
			return this;
		}

		public Query RankedByAveragePlaytimeTrend()
		{
			queryType = UGCQuery.RankedByAveragePlaytimeTrend;
			return this;
		}

		public Query RankedByLifetimeAveragePlaytime()
		{
			queryType = UGCQuery.RankedByLifetimeAveragePlaytime;
			return this;
		}

		public Query RankedByPlaytimeSessionsTrend()
		{
			queryType = UGCQuery.RankedByPlaytimeSessionsTrend;
			return this;
		}

		public Query RankedByLifetimePlaytimeSessions()
		{
			queryType = UGCQuery.RankedByLifetimePlaytimeSessions;
			return this;
		}

		internal Query LimitUser(SteamId steamid)
		{
			if (steamid.Value == 0L)
			{
				steamid = SteamClient.SteamId;
			}
			this.steamid = steamid;
			return this;
		}

		public Query WhereUserPublished(SteamId user = default(SteamId))
		{
			userType = UserUGCList.Published;
			LimitUser(user);
			return this;
		}

		public Query WhereUserVotedOn(SteamId user = default(SteamId))
		{
			userType = UserUGCList.VotedOn;
			LimitUser(user);
			return this;
		}

		public Query WhereUserVotedUp(SteamId user = default(SteamId))
		{
			userType = UserUGCList.VotedUp;
			LimitUser(user);
			return this;
		}

		public Query WhereUserVotedDown(SteamId user = default(SteamId))
		{
			userType = UserUGCList.VotedDown;
			LimitUser(user);
			return this;
		}

		public Query WhereUserWillVoteLater(SteamId user = default(SteamId))
		{
			userType = UserUGCList.WillVoteLater;
			LimitUser(user);
			return this;
		}

		public Query WhereUserFavorited(SteamId user = default(SteamId))
		{
			userType = UserUGCList.Favorited;
			LimitUser(user);
			return this;
		}

		public Query WhereUserSubscribed(SteamId user = default(SteamId))
		{
			userType = UserUGCList.Subscribed;
			LimitUser(user);
			return this;
		}

		public Query WhereUserUsedOrPlayed(SteamId user = default(SteamId))
		{
			userType = UserUGCList.UsedOrPlayed;
			LimitUser(user);
			return this;
		}

		public Query WhereUserFollowed(SteamId user = default(SteamId))
		{
			userType = UserUGCList.Followed;
			LimitUser(user);
			return this;
		}

		public Query SortByCreationDate()
		{
			userSort = UserUGCListSortOrder.CreationOrderDesc;
			return this;
		}

		public Query SortByCreationDateAsc()
		{
			userSort = UserUGCListSortOrder.CreationOrderAsc;
			return this;
		}

		public Query SortByTitleAsc()
		{
			userSort = UserUGCListSortOrder.TitleAsc;
			return this;
		}

		public Query SortByUpdateDate()
		{
			userSort = UserUGCListSortOrder.LastUpdatedDesc;
			return this;
		}

		public Query SortBySubscriptionDate()
		{
			userSort = UserUGCListSortOrder.SubscriptionDateDesc;
			return this;
		}

		public Query SortByVoteScore()
		{
			userSort = UserUGCListSortOrder.VoteScoreDesc;
			return this;
		}

		public Query SortByModeration()
		{
			userSort = UserUGCListSortOrder.ForModeration;
			return this;
		}

		public Query WhereSearchText(string searchText)
		{
			this.searchText = searchText;
			return this;
		}

		public Query WithFileId(params PublishedFileId[] files)
		{
			Files = files;
			return this;
		}

		public async Task<ResultPage?> GetPageAsync(int page)
		{
			if (page <= 0)
			{
				throw new Exception("page should be > 0");
			}
			if ((uint)consumerApp == 0)
			{
				consumerApp = SteamClient.AppId;
			}
			if ((uint)creatorApp == 0)
			{
				creatorApp = consumerApp;
			}
			UGCQueryHandle_t handle = ((Files != null) ? SteamUGC.Internal.CreateQueryUGCDetailsRequest(Files, (uint)Files.Length) : ((!steamid.HasValue) ? SteamUGC.Internal.CreateQueryAllUGCRequest(queryType, matchingType, creatorApp.Value, consumerApp.Value, (uint)page) : SteamUGC.Internal.CreateQueryUserUGCRequest(steamid.Value.AccountId, userType, matchingType, userSort, creatorApp.Value, consumerApp.Value, (uint)page)));
			ApplyReturns(handle);
			if (maxCacheAge.HasValue)
			{
				SteamUGC.Internal.SetAllowCachedResponse(handle, (uint)maxCacheAge.Value);
			}
			ApplyConstraints(handle);
			SteamUGCQueryCompleted_t? steamUGCQueryCompleted_t = await SteamUGC.Internal.SendQueryUGCRequest(handle);
			if (!steamUGCQueryCompleted_t.HasValue)
			{
				return null;
			}
			if (steamUGCQueryCompleted_t.Value.Result != Result.OK)
			{
				return null;
			}
			ResultPage value = default(ResultPage);
			value.Handle = steamUGCQueryCompleted_t.Value.Handle;
			value.ResultCount = (int)steamUGCQueryCompleted_t.Value.NumResultsReturned;
			value.TotalCount = (int)steamUGCQueryCompleted_t.Value.TotalMatchingResults;
			value.CachedData = steamUGCQueryCompleted_t.Value.CachedData;
			return value;
		}

		public Query WithType(UgcType type)
		{
			matchingType = type;
			return this;
		}

		public Query AllowCachedResponse(int maxSecondsAge)
		{
			maxCacheAge = maxSecondsAge;
			return this;
		}

		public Query InLanguage(string lang)
		{
			language = lang;
			return this;
		}

		public Query WithTrendDays(int days)
		{
			trendDays = days;
			return this;
		}

		public Query MatchAnyTag()
		{
			matchAnyTag = true;
			return this;
		}

		public Query MatchAllTags()
		{
			matchAnyTag = false;
			return this;
		}

		public Query WithTag(string tag)
		{
			if (requiredTags == null)
			{
				requiredTags = new List<string>();
			}
			requiredTags.Add(tag);
			return this;
		}

		public Query AddRequiredKeyValueTag(string key, string value)
		{
			if (requiredKv == null)
			{
				requiredKv = new Dictionary<string, string>();
			}
			requiredKv.Add(key, value);
			return this;
		}

		public Query WithoutTag(string tag)
		{
			if (excludedTags == null)
			{
				excludedTags = new List<string>();
			}
			excludedTags.Add(tag);
			return this;
		}

		private void ApplyConstraints(UGCQueryHandle_t handle)
		{
			if (requiredTags != null)
			{
				foreach (string requiredTag in requiredTags)
				{
					SteamUGC.Internal.AddRequiredTag(handle, requiredTag);
				}
			}
			if (excludedTags != null)
			{
				foreach (string excludedTag in excludedTags)
				{
					SteamUGC.Internal.AddExcludedTag(handle, excludedTag);
				}
			}
			if (requiredKv != null)
			{
				foreach (KeyValuePair<string, string> item in requiredKv)
				{
					SteamUGC.Internal.AddRequiredKeyValueTag(handle, item.Key, item.Value);
				}
			}
			if (matchAnyTag.HasValue)
			{
				SteamUGC.Internal.SetMatchAnyTag(handle, matchAnyTag.Value);
			}
			if (trendDays.HasValue)
			{
				SteamUGC.Internal.SetRankedByTrendDays(handle, (uint)trendDays.Value);
			}
			if (!string.IsNullOrEmpty(searchText))
			{
				SteamUGC.Internal.SetSearchText(handle, searchText);
			}
		}

		public Query WithOnlyIDs(bool b)
		{
			WantsReturnOnlyIDs = b;
			return this;
		}

		public Query WithKeyValueTag(bool b)
		{
			WantsReturnKeyValueTags = b;
			return this;
		}

		public Query WithLongDescription(bool b)
		{
			WantsReturnLongDescription = b;
			return this;
		}

		public Query WithMetadata(bool b)
		{
			WantsReturnMetadata = b;
			return this;
		}

		public Query WithChildren(bool b)
		{
			WantsReturnChildren = b;
			return this;
		}

		public Query WithAdditionalPreviews(bool b)
		{
			WantsReturnAdditionalPreviews = b;
			return this;
		}

		public Query WithTotalOnly(bool b)
		{
			WantsReturnTotalOnly = b;
			return this;
		}

		public Query WithPlaytimeStats(uint unDays)
		{
			WantsReturnPlaytimeStats = unDays;
			return this;
		}

		private void ApplyReturns(UGCQueryHandle_t handle)
		{
			if (WantsReturnOnlyIDs.HasValue)
			{
				SteamUGC.Internal.SetReturnOnlyIDs(handle, WantsReturnOnlyIDs.Value);
			}
			if (WantsReturnKeyValueTags.HasValue)
			{
				SteamUGC.Internal.SetReturnKeyValueTags(handle, WantsReturnKeyValueTags.Value);
			}
			if (WantsReturnLongDescription.HasValue)
			{
				SteamUGC.Internal.SetReturnLongDescription(handle, WantsReturnLongDescription.Value);
			}
			if (WantsReturnMetadata.HasValue)
			{
				SteamUGC.Internal.SetReturnMetadata(handle, WantsReturnMetadata.Value);
			}
			if (WantsReturnChildren.HasValue)
			{
				SteamUGC.Internal.SetReturnChildren(handle, WantsReturnChildren.Value);
			}
			if (WantsReturnAdditionalPreviews.HasValue)
			{
				SteamUGC.Internal.SetReturnAdditionalPreviews(handle, WantsReturnAdditionalPreviews.Value);
			}
			if (WantsReturnTotalOnly.HasValue)
			{
				SteamUGC.Internal.SetReturnTotalOnly(handle, WantsReturnTotalOnly.Value);
			}
			if (WantsReturnPlaytimeStats.HasValue)
			{
				SteamUGC.Internal.SetReturnPlaytimeStats(handle, WantsReturnPlaytimeStats.Value);
			}
		}
	}
	public struct ResultPage : IDisposable
	{
		[CompilerGenerated]
		private sealed class <get_Entries>d__5 : IEnumerable<Item>, IEnumerable, IEnumerator<Item>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private Item <>2__current;

			private int <>l__initialThreadId;

			public ResultPage <>4__this;

			public ResultPage <>3__<>4__this;

			private SteamUGCDetails_t <details>5__2;

			private uint <i>5__3;

			Item IEnumerator<Item>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <get_Entries>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<details>5__2 = default(SteamUGCDetails_t);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_01eb;
				}
				<>1__state = -1;
				<details>5__2 = default(SteamUGCDetails_t);
				<i>5__3 = 0u;
				goto IL_01fb;
				IL_01eb:
				<i>5__3++;
				goto IL_01fb;
				IL_01fb:
				if (<i>5__3 < <>4__this.ResultCount)
				{
					if (SteamUGC.Internal.GetQueryUGCResult(<>4__this.Handle, <i>5__3, ref <details>5__2))
					{
						Item item = Item.From(<details>5__2);
						item.NumSubscriptions = <>4__this.GetStat(<i>5__3, ItemStatistic.NumSubscriptions);
						item.NumFavorites = <>4__this.GetStat(<i>5__3, ItemStatistic.NumFavorites);
						item.NumFollowers = <>4__this.GetStat(<i>5__3, ItemStatistic.NumFollowers);
						item.NumUniqueSubscriptions = <>4__this.GetStat(<i>5__3, ItemStatistic.NumUniqueSubscriptions);
						item.NumUniqueFavorites = <>4__this.GetStat(<i>5__3, ItemStatistic.NumUniqueFavorites);
						item.NumUniqueFollowers = <>4__this.GetStat(<i>5__3, ItemStatistic.NumUniqueFollowers);
						item.NumUniqueWebsiteViews = <>4__this.GetStat(<i>5__3, ItemStatistic.NumUniqueWebsiteViews);
						item.ReportScore = <>4__this.GetStat(<i>5__3, ItemStatistic.ReportScore);
						item.NumSecondsPlayed = <>4__this.GetStat(<i>5__3, ItemStatistic.NumSecondsPlayed);
						item.NumPlaytimeSessions = <>4__this.GetStat(<i>5__3, ItemStatistic.NumPlaytimeSessions);
						item.NumComments = <>4__this.GetStat(<i>5__3, ItemStatistic.NumComments);
						item.NumSecondsPlayedDuringTimePeriod = <>4__this.GetStat(<i>5__3, ItemStatistic.NumSecondsPlayedDuringTimePeriod);
						item.NumPlaytimeSessionsDuringTimePeriod = <>4__this.GetStat(<i>5__3, ItemStatistic.NumPlaytimeSessionsDuringTimePeriod);
						if (SteamUGC.Internal.GetQueryUGCPreviewURL(<>4__this.Handle, <i>5__3, out var pchURL))
						{
							item.PreviewImageUrl = pchURL;
						}
						<>2__current = item;
						<>1__state = 1;
						return true;
					}
					goto IL_01eb;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<Item> IEnumerable<Item>.GetEnumerator()
			{
				<get_Entries>d__5 <get_Entries>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<get_Entries>d__ = this;
				}
				else
				{
					<get_Entries>d__ = new <get_Entries>d__5(0);
				}
				<get_Entries>d__.<>4__this = <>3__<>4__this;
				return <get_Entries>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Item>)this).GetEnumerator();
			}
		}

		internal UGCQueryHandle_t Handle;

		public int ResultCount;

		public int TotalCount;

		public bool CachedData;

		public IEnumerable<Item> Entries
		{
			[IteratorStateMachine(typeof(<get_Entries>d__5))]
			get
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <get_Entries>d__5(-2)
				{
					<>3__<>4__this = this
				};
			}
		}

		private ulong GetStat(uint index, ItemStatistic stat)
		{
			ulong pStatValue = 0uL;
			if (!SteamUGC.Internal.GetQueryUGCStatistic(Handle, index, stat, ref pStatValue))
			{
				return 0uL;
			}
			return pStatValue;
		}

		public void Dispose()
		{
			if ((ulong)Handle != 0)
			{
				SteamUGC.Internal.ReleaseQueryUGCRequest(Handle);
				Handle = 0uL;
			}
		}
	}
	public struct UserItemVote
	{
		public bool VotedUp;

		public bool VotedDown;

		public bool VoteSkipped;

		internal static UserItemVote? From(GetUserItemVoteResult_t result)
		{
			UserItemVote value = default(UserItemVote);
			value.VotedUp = result.VotedUp;
			value.VotedDown = result.VotedDown;
			value.VoteSkipped = result.VoteSkipped;
			return value;
		}
	}
}
namespace Steamworks.ServerList
{
	public abstract class Base : IDisposable
	{
		public List<ServerInfo> Responsive = new List<ServerInfo>();

		public List<ServerInfo> Unresponsive = new List<ServerInfo>();

		internal HServerListRequest request;

		internal List<MatchMakingKeyValuePair> filters = new List<MatchMakingKeyValuePair>();

		internal List<int> watchList = new List<int>();

		internal int LastCount;

		internal static ISteamMatchmakingServers Internal => SteamMatchmakingServers.Internal;

		public AppId AppId { get; set; }

		internal int Count => Internal.GetServerCount(request);

		internal bool IsRefreshing
		{
			get
			{
				if (request.Value != IntPtr.Zero)
				{
					return Internal.IsRefreshing(request);
				}
				return false;
			}
		}

		public event Action OnChanges;

		public event Action<ServerInfo> OnResponsiveServer;

		public Base()
		{
			AppId = SteamClient.AppId;
		}

		public virtual async Task<bool> RunQueryAsync(float timeoutSeconds = 10f)
		{
			Stopwatch stopwatch = Stopwatch.StartNew();
			Reset();
			LaunchQuery();
			HServerListRequest thisRequest = request;
			while (IsRefreshing)
			{
				await Task.Delay(33);
				if (request.Value == IntPtr.Zero || thisRequest.Value != request.Value)
				{
					return false;
				}
				if (!SteamClient.IsValid)
				{
					return false;
				}
				int count = Responsive.Count;
				UpdatePending();
				UpdateResponsive();
				if (count != Responsive.Count)
				{
					InvokeChanges();
				}
				if (stopwatch.Elapsed.TotalSeconds > (double)timeoutSeconds)
				{
					break;
				}
			}
			MovePendingToUnresponsive();
			InvokeChanges();
			return true;
		}

		public virtual void Cancel()
		{
			Internal.CancelQuery(request);
		}

		internal abstract void LaunchQuery();

		internal virtual MatchMakingKeyValuePair[] GetFilters()
		{
			return filters.ToArray();
		}

		public void AddFilter(string key, string value)
		{
			filters.Add(new MatchMakingKeyValuePair
			{
				Key = key,
				Value = value
			});
		}

		private void Reset()
		{
			ReleaseQuery();
			LastCount = 0;
			watchList.Clear();
		}

		private void ReleaseQuery()
		{
			if (request.Value != IntPtr.Zero)
			{
				Cancel();
				Internal.ReleaseRequest(request);
				request = IntPtr.Zero;
			}
		}

		public void Dispose()
		{
			ReleaseQuery();
		}

		internal void InvokeChanges()
		{
			this.OnChanges?.Invoke();
		}

		private void UpdatePending()
		{
			int count = Count;
			if (count != LastCount)
			{
				for (int i = LastCount; i < count; i++)
				{
					watchList.Add(i);
				}
				LastCount = count;
			}
		}

		public void UpdateResponsive()
		{
			watchList.RemoveAll(delegate(int x)
			{
				gameserveritem_t serverDetails = Internal.GetServerDetails(request, x);
				if (serverDetails.HadSuccessfulResponse)
				{
					OnServer(ServerInfo.From(serverDetails), serverDetails.HadSuccessfulResponse);
					return true;
				}
				return false;
			});
		}

		private void MovePendingToUnresponsive()
		{
			watchList.RemoveAll(delegate(int x)
			{
				gameserveritem_t serverDetails = Internal.GetServerDetails(request, x);
				OnServer(ServerInfo.From(serverDetails), serverDetails.HadSuccessfulResponse);
				return true;
			});
		}

		private void OnServer(ServerInfo serverInfo, bool responded)
		{
			if (responded)
			{
				Responsive.Add(serverInfo);
				this.OnResponsiveServer?.Invoke(serverInfo);
			}
			else
			{
				Unresponsive.Add(serverInfo);
			}
		}
	}
	public class Favourites : Base
	{
		internal override void LaunchQuery()
		{
			MatchMakingKeyValuePair[] ppchFilters = GetFilters();
			request = Base.Internal.RequestFavoritesServerList(base.AppId.Value, ref ppchFilters, (uint)ppchFilters.Length, IntPtr.Zero);
		}
	}
	public class Friends : Base
	{
		internal override void LaunchQuery()
		{
			MatchMakingKeyValuePair[] ppchFilters = GetFilters();
			request = Base.Internal.RequestFriendsServerList(base.AppId.Value, ref ppchFilters, (uint)ppchFilters.Length, IntPtr.Zero);
		}
	}
	public class History : Base
	{
		internal override void LaunchQuery()
		{
			MatchMakingKeyValuePair[] ppchFilters = GetFilters();
			request = Base.Internal.RequestHistoryServerList(base.AppId.Value, ref ppchFilters, (uint)ppchFilters.Length, IntPtr.Zero);
		}
	}
	public class Internet : Base
	{
		internal override void LaunchQuery()
		{
			MatchMakingKeyValuePair[] ppchFilters = GetFilters();
			request = Base.Internal.RequestInternetServerList(base.AppId.Value, ref ppchFilters, (uint)ppchFilters.Length, IntPtr.Zero);
		}
	}
	public class IpList : Internet
	{
		public List<string> Ips = new List<string>();

		private bool wantsCancel;

		public IpList(IEnumerable<string> list)
		{
			Ips.AddRange(list);
		}

		public IpList(params string[] list)
		{
			Ips.AddRange(list);
		}

		public override async Task<bool> RunQueryAsync(float timeoutSeconds = 10f)
		{
			int blockSize = 16;
			int pointer = 0;
			string[] ips = Ips.ToArray();
			while (true)
			{
				IEnumerable<string> sublist = ips.Skip(pointer).Take(blockSize);
				if (sublist.Count() == 0)
				{
					break;
				}
				using (Internet list = new Internet())
				{
					list.AddFilter("or", sublist.Count().ToString());
					foreach (string item in sublist)
					{
						list.AddFilter("gameaddr", item);
					}
					await list.RunQueryAsync(timeoutSeconds);
					if (wantsCancel)
					{
						return false;
					}
					Responsive.AddRange(list.Responsive);
					Responsive = Responsive.Distinct().ToList();
					Unresponsive.AddRange(list.Unresponsive);
					Unresponsive = Unresponsive.Distinct().ToList();
				}
				pointer += sublist.Count();
				InvokeChanges();
			}
			return true;
		}

		public override void Cancel()
		{
			wantsCancel = true;
		}
	}
	public class LocalNetwork : Base
	{
		internal override void LaunchQuery()
		{
			request = Base.Internal.RequestLANServerList(base.AppId.Value, IntPtr.Zero);
		}
	}
}
namespace Steamworks.Data
{
	public enum LeaderboardDisplay
	{
		Numeric = 1,
		TimeSeconds,
		TimeMilliSeconds
	}
	public enum LeaderboardSort
	{
		Ascending = 1,
		Descending
	}
	[Flags]
	public enum SendType
	{
		Unreliable = 0,
		NoNagle = 1,
		NoDelay = 4,
		Reliable = 8
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamServersConnected_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(SteamServersConnected_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamServersConnected;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamServerConnectFailure_t : ICallbackData
	{
		internal Result Result;

		[MarshalAs(UnmanagedType.I1)]
		internal bool StillRetrying;

		public static int _datasize = Marshal.SizeOf(typeof(SteamServerConnectFailure_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamServerConnectFailure;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamServersDisconnected_t : ICallbackData
	{
		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(SteamServersDisconnected_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamServersDisconnected;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct ClientGameServerDeny_t : ICallbackData
	{
		internal uint AppID;

		internal uint GameServerIP;

		internal ushort GameServerPort;

		internal ushort Secure;

		internal uint Reason;

		public static int _datasize = Marshal.SizeOf(typeof(ClientGameServerDeny_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.ClientGameServerDeny;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct IPCFailure_t : ICallbackData
	{
		internal enum EFailureType
		{
			FlushedCallbackQueue,
			PipeFail
		}

		internal byte FailureType;

		public static int _datasize = Marshal.SizeOf(typeof(IPCFailure_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.IPCFailure;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LicensesUpdated_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(LicensesUpdated_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LicensesUpdated;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct ValidateAuthTicketResponse_t : ICallbackData
	{
		internal ulong SteamID;

		internal AuthResponse AuthSessionResponse;

		internal ulong OwnerSteamID;

		public static int _datasize = Marshal.SizeOf(typeof(ValidateAuthTicketResponse_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.ValidateAuthTicketResponse;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MicroTxnAuthorizationResponse_t : ICallbackData
	{
		internal uint AppID;

		internal ulong OrderID;

		internal byte Authorized;

		public static int _datasize = Marshal.SizeOf(typeof(MicroTxnAuthorizationResponse_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MicroTxnAuthorizationResponse;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct EncryptedAppTicketResponse_t : ICallbackData
	{
		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(EncryptedAppTicketResponse_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.EncryptedAppTicketResponse;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GetAuthSessionTicketResponse_t : ICallbackData
	{
		internal uint AuthTicket;

		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(GetAuthSessionTicketResponse_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GetAuthSessionTicketResponse;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GameWebCallback_t : ICallbackData
	{
		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
		internal byte[] URL;

		public static int _datasize = Marshal.SizeOf(typeof(GameWebCallback_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GameWebCallback;

		internal string URLUTF8()
		{
			return Encoding.UTF8.GetString(URL, 0, Array.IndexOf(URL, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct StoreAuthURLResponse_t : ICallbackData
	{
		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 512)]
		internal byte[] URL;

		public static int _datasize = Marshal.SizeOf(typeof(StoreAuthURLResponse_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.StoreAuthURLResponse;

		internal string URLUTF8()
		{
			return Encoding.UTF8.GetString(URL, 0, Array.IndexOf(URL, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MarketEligibilityResponse_t : ICallbackData
	{
		[MarshalAs(UnmanagedType.I1)]
		internal bool Allowed;

		internal MarketNotAllowedReasonFlags NotAllowedReason;

		internal uint TAllowedAtTime;

		internal int CdaySteamGuardRequiredDays;

		internal int CdayNewDeviceCooldown;

		public static int _datasize = Marshal.SizeOf(typeof(MarketEligibilityResponse_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MarketEligibilityResponse;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct DurationControl_t : ICallbackData
	{
		internal Result Result;

		internal AppId Appid;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Applicable;

		internal int CsecsLast5h;

		internal DurationControlProgress Progress;

		internal DurationControlNotification Otification;

		internal int CsecsToday;

		internal int CsecsRemaining;

		public static int _datasize = Marshal.SizeOf(typeof(DurationControl_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.DurationControl;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct PersonaStateChange_t : ICallbackData
	{
		internal ulong SteamID;

		internal int ChangeFlags;

		public static int _datasize = Marshal.SizeOf(typeof(PersonaStateChange_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.PersonaStateChange;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GameOverlayActivated_t : ICallbackData
	{
		internal byte Active;

		public static int _datasize = Marshal.SizeOf(typeof(GameOverlayActivated_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GameOverlayActivated;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GameServerChangeRequested_t : ICallbackData
	{
		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
		internal byte[] Server;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
		internal byte[] Password;

		public static int _datasize = Marshal.SizeOf(typeof(GameServerChangeRequested_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GameServerChangeRequested;

		internal string ServerUTF8()
		{
			return Encoding.UTF8.GetString(Server, 0, Array.IndexOf(Server, (byte)0));
		}

		internal string PasswordUTF8()
		{
			return Encoding.UTF8.GetString(Password, 0, Array.IndexOf(Password, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct GameLobbyJoinRequested_t : ICallbackData
	{
		internal ulong SteamIDLobby;

		internal ulong SteamIDFriend;

		public static int _datasize = Marshal.SizeOf(typeof(GameLobbyJoinRequested_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GameLobbyJoinRequested;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct AvatarImageLoaded_t : ICallbackData
	{
		internal ulong SteamID;

		internal int Image;

		internal int Wide;

		internal int Tall;

		public static int _datasize = Marshal.SizeOf(typeof(AvatarImageLoaded_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.AvatarImageLoaded;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct ClanOfficerListResponse_t : ICallbackData
	{
		internal ulong SteamIDClan;

		internal int COfficers;

		internal byte Success;

		public static int _datasize = Marshal.SizeOf(typeof(ClanOfficerListResponse_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.ClanOfficerListResponse;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct FriendRichPresenceUpdate_t : ICallbackData
	{
		internal ulong SteamIDFriend;

		internal AppId AppID;

		public static int _datasize = Marshal.SizeOf(typeof(FriendRichPresenceUpdate_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.FriendRichPresenceUpdate;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GameRichPresenceJoinRequested_t : ICallbackData
	{
		internal ulong SteamIDFriend;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
		internal byte[] Connect;

		public static int _datasize = Marshal.SizeOf(typeof(GameRichPresenceJoinRequested_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GameRichPresenceJoinRequested;

		internal string ConnectUTF8()
		{
			return Encoding.UTF8.GetString(Connect, 0, Array.IndexOf(Connect, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct GameConnectedClanChatMsg_t : ICallbackData
	{
		internal ulong SteamIDClanChat;

		internal ulong SteamIDUser;

		internal int MessageID;

		public static int _datasize = Marshal.SizeOf(typeof(GameConnectedClanChatMsg_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GameConnectedClanChatMsg;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct GameConnectedChatJoin_t : ICallbackData
	{
		internal ulong SteamIDClanChat;

		internal ulong SteamIDUser;

		public static int _datasize = Marshal.SizeOf(typeof(GameConnectedChatJoin_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GameConnectedChatJoin;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct GameConnectedChatLeave_t : ICallbackData
	{
		internal ulong SteamIDClanChat;

		internal ulong SteamIDUser;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Kicked;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Dropped;

		public static int _datasize = Marshal.SizeOf(typeof(GameConnectedChatLeave_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GameConnectedChatLeave;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct DownloadClanActivityCountsResult_t : ICallbackData
	{
		[MarshalAs(UnmanagedType.I1)]
		internal bool Success;

		public static int _datasize = Marshal.SizeOf(typeof(DownloadClanActivityCountsResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.DownloadClanActivityCountsResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct JoinClanChatRoomCompletionResult_t : ICallbackData
	{
		internal ulong SteamIDClanChat;

		internal RoomEnter ChatRoomEnterResponse;

		public static int _datasize = Marshal.SizeOf(typeof(JoinClanChatRoomCompletionResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.JoinClanChatRoomCompletionResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GameConnectedFriendChatMsg_t : ICallbackData
	{
		internal ulong SteamIDUser;

		internal int MessageID;

		public static int _datasize = Marshal.SizeOf(typeof(GameConnectedFriendChatMsg_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GameConnectedFriendChatMsg;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct FriendsGetFollowerCount_t : ICallbackData
	{
		internal Result Result;

		internal ulong SteamID;

		internal int Count;

		public static int _datasize = Marshal.SizeOf(typeof(FriendsGetFollowerCount_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.FriendsGetFollowerCount;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct FriendsIsFollowing_t : ICallbackData
	{
		internal Result Result;

		internal ulong SteamID;

		[MarshalAs(UnmanagedType.I1)]
		internal bool IsFollowing;

		public static int _datasize = Marshal.SizeOf(typeof(FriendsIsFollowing_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.FriendsIsFollowing;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct FriendsEnumerateFollowingList_t : ICallbackData
	{
		internal Result Result;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.U8)]
		internal ulong[] GSteamID;

		internal int ResultsReturned;

		internal int TotalResultCount;

		public static int _datasize = Marshal.SizeOf(typeof(FriendsEnumerateFollowingList_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.FriendsEnumerateFollowingList;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SetPersonaNameResponse_t : ICallbackData
	{
		[MarshalAs(UnmanagedType.I1)]
		internal bool Success;

		[MarshalAs(UnmanagedType.I1)]
		internal bool LocalSuccess;

		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(SetPersonaNameResponse_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SetPersonaNameResponse;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct UnreadChatMessagesChanged_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(UnreadChatMessagesChanged_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.UnreadChatMessagesChanged;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct IPCountry_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(IPCountry_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.IPCountry;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LowBatteryPower_t : ICallbackData
	{
		internal byte MinutesBatteryLeft;

		public static int _datasize = Marshal.SizeOf(typeof(LowBatteryPower_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LowBatteryPower;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamAPICallCompleted_t : ICallbackData
	{
		internal ulong AsyncCall;

		internal int Callback;

		internal uint ParamCount;

		public static int _datasize = Marshal.SizeOf(typeof(SteamAPICallCompleted_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamAPICallCompleted;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamShutdown_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(SteamShutdown_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamShutdown;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct CheckFileSignature_t : ICallbackData
	{
		internal CheckFileSignature CheckFileSignature;

		public static int _datasize = Marshal.SizeOf(typeof(CheckFileSignature_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.CheckFileSignature;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GamepadTextInputDismissed_t : ICallbackData
	{
		[MarshalAs(UnmanagedType.I1)]
		internal bool Submitted;

		internal uint SubmittedText;

		public static int _datasize = Marshal.SizeOf(typeof(GamepadTextInputDismissed_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GamepadTextInputDismissed;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct FavoritesListChanged_t : ICallbackData
	{
		internal uint IP;

		internal uint QueryPort;

		internal uint ConnPort;

		internal uint AppID;

		internal uint Flags;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Add;

		internal uint AccountId;

		public static int _datasize = Marshal.SizeOf(typeof(FavoritesListChanged_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.FavoritesListChanged;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LobbyInvite_t : ICallbackData
	{
		internal ulong SteamIDUser;

		internal ulong SteamIDLobby;

		internal ulong GameID;

		public static int _datasize = Marshal.SizeOf(typeof(LobbyInvite_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LobbyInvite;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LobbyEnter_t : ICallbackData
	{
		internal ulong SteamIDLobby;

		internal uint GfChatPermissions;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Locked;

		internal uint EChatRoomEnterResponse;

		public static int _datasize = Marshal.SizeOf(typeof(LobbyEnter_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LobbyEnter;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LobbyDataUpdate_t : ICallbackData
	{
		internal ulong SteamIDLobby;

		internal ulong SteamIDMember;

		internal byte Success;

		public static int _datasize = Marshal.SizeOf(typeof(LobbyDataUpdate_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LobbyDataUpdate;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LobbyChatUpdate_t : ICallbackData
	{
		internal ulong SteamIDLobby;

		internal ulong SteamIDUserChanged;

		internal ulong SteamIDMakingChange;

		internal uint GfChatMemberStateChange;

		public static int _datasize = Marshal.SizeOf(typeof(LobbyChatUpdate_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LobbyChatUpdate;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LobbyChatMsg_t : ICallbackData
	{
		internal ulong SteamIDLobby;

		internal ulong SteamIDUser;

		internal byte ChatEntryType;

		internal uint ChatID;

		public static int _datasize = Marshal.SizeOf(typeof(LobbyChatMsg_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LobbyChatMsg;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LobbyGameCreated_t : ICallbackData
	{
		internal ulong SteamIDLobby;

		internal ulong SteamIDGameServer;

		internal uint IP;

		internal ushort Port;

		public static int _datasize = Marshal.SizeOf(typeof(LobbyGameCreated_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LobbyGameCreated;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LobbyMatchList_t : ICallbackData
	{
		internal uint LobbiesMatching;

		public static int _datasize = Marshal.SizeOf(typeof(LobbyMatchList_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LobbyMatchList;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LobbyKicked_t : ICallbackData
	{
		internal ulong SteamIDLobby;

		internal ulong SteamIDAdmin;

		internal byte KickedDueToDisconnect;

		public static int _datasize = Marshal.SizeOf(typeof(LobbyKicked_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LobbyKicked;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LobbyCreated_t : ICallbackData
	{
		internal Result Result;

		internal ulong SteamIDLobby;

		public static int _datasize = Marshal.SizeOf(typeof(LobbyCreated_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LobbyCreated;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct PSNGameBootInviteResult_t : ICallbackData
	{
		[MarshalAs(UnmanagedType.I1)]
		internal bool GameBootInviteExists;

		internal ulong SteamIDLobby;

		public static int _datasize = Marshal.SizeOf(typeof(PSNGameBootInviteResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.PSNGameBootInviteResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct FavoritesListAccountsUpdated_t : ICallbackData
	{
		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(FavoritesListAccountsUpdated_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.FavoritesListAccountsUpdated;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct SearchForGameProgressCallback_t : ICallbackData
	{
		internal ulong LSearchID;

		internal Result Result;

		internal ulong LobbyID;

		internal ulong SteamIDEndedSearch;

		internal int SecondsRemainingEstimate;

		internal int CPlayersSearching;

		public static int _datasize = Marshal.SizeOf(typeof(SearchForGameProgressCallback_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SearchForGameProgressCallback;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct SearchForGameResultCallback_t : ICallbackData
	{
		internal ulong LSearchID;

		internal Result Result;

		internal int CountPlayersInGame;

		internal int CountAcceptedGame;

		internal ulong SteamIDHost;

		[MarshalAs(UnmanagedType.I1)]
		internal bool FinalCallback;

		public static int _datasize = Marshal.SizeOf(typeof(SearchForGameResultCallback_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SearchForGameResultCallback;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RequestPlayersForGameProgressCallback_t : ICallbackData
	{
		internal Result Result;

		internal ulong LSearchID;

		public static int _datasize = Marshal.SizeOf(typeof(RequestPlayersForGameProgressCallback_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RequestPlayersForGameProgressCallback;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct RequestPlayersForGameResultCallback_t : ICallbackData
	{
		internal enum PlayerAcceptState_t
		{
			Unknown,
			PlayerAccepted,
			PlayerDeclined
		}

		internal Result Result;

		internal ulong LSearchID;

		internal ulong SteamIDPlayerFound;

		internal ulong SteamIDLobby;

		internal PlayerAcceptState_t PlayerAcceptState;

		internal int PlayerIndex;

		internal int TotalPlayersFound;

		internal int TotalPlayersAcceptedGame;

		internal int SuggestedTeamIndex;

		internal ulong LUniqueGameID;

		public static int _datasize = Marshal.SizeOf(typeof(RequestPlayersForGameResultCallback_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RequestPlayersForGameResultCallback;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RequestPlayersForGameFinalResultCallback_t : ICallbackData
	{
		internal Result Result;

		internal ulong LSearchID;

		internal ulong LUniqueGameID;

		public static int _datasize = Marshal.SizeOf(typeof(RequestPlayersForGameFinalResultCallback_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RequestPlayersForGameFinalResultCallback;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct SubmitPlayerResultResultCallback_t : ICallbackData
	{
		internal Result Result;

		internal ulong UllUniqueGameID;

		internal ulong SteamIDPlayer;

		public static int _datasize = Marshal.SizeOf(typeof(SubmitPlayerResultResultCallback_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SubmitPlayerResultResultCallback;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct EndGameResultCallback_t : ICallbackData
	{
		internal Result Result;

		internal ulong UllUniqueGameID;

		public static int _datasize = Marshal.SizeOf(typeof(EndGameResultCallback_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.EndGameResultCallback;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct JoinPartyCallback_t : ICallbackData
	{
		internal Result Result;

		internal ulong BeaconID;

		internal ulong SteamIDBeaconOwner;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
		internal byte[] ConnectString;

		public static int _datasize = Marshal.SizeOf(typeof(JoinPartyCallback_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.JoinPartyCallback;

		internal string ConnectStringUTF8()
		{
			return Encoding.UTF8.GetString(ConnectString, 0, Array.IndexOf(ConnectString, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct CreateBeaconCallback_t : ICallbackData
	{
		internal Result Result;

		internal ulong BeaconID;

		public static int _datasize = Marshal.SizeOf(typeof(CreateBeaconCallback_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.CreateBeaconCallback;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct ReservationNotificationCallback_t : ICallbackData
	{
		internal ulong BeaconID;

		internal ulong SteamIDJoiner;

		public static int _datasize = Marshal.SizeOf(typeof(ReservationNotificationCallback_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.ReservationNotificationCallback;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct ChangeNumOpenSlotsCallback_t : ICallbackData
	{
		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(ChangeNumOpenSlotsCallback_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.ChangeNumOpenSlotsCallback;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct AvailableBeaconLocationsUpdated_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(AvailableBeaconLocationsUpdated_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.AvailableBeaconLocationsUpdated;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct ActiveBeaconsUpdated_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(ActiveBeaconsUpdated_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.ActiveBeaconsUpdated;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageAppSyncedClient_t : ICallbackData
	{
		internal AppId AppID;

		internal Result Result;

		internal int NumDownloads;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageAppSyncedClient_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageAppSyncedClient;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageAppSyncedServer_t : ICallbackData
	{
		internal AppId AppID;

		internal Result Result;

		internal int NumUploads;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageAppSyncedServer_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageAppSyncedServer;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageAppSyncProgress_t : ICallbackData
	{
		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 260)]
		internal byte[] CurrentFile;

		internal AppId AppID;

		internal uint BytesTransferredThisChunk;

		internal double DAppPercentComplete;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Uploading;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageAppSyncProgress_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageAppSyncProgress;

		internal string CurrentFileUTF8()
		{
			return Encoding.UTF8.GetString(CurrentFile, 0, Array.IndexOf(CurrentFile, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageAppSyncStatusCheck_t : ICallbackData
	{
		internal AppId AppID;

		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageAppSyncStatusCheck_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageAppSyncStatusCheck;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageFileShareResult_t : ICallbackData
	{
		internal Result Result;

		internal ulong File;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 260)]
		internal byte[] Filename;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageFileShareResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageFileShareResult;

		internal string FilenameUTF8()
		{
			return Encoding.UTF8.GetString(Filename, 0, Array.IndexOf(Filename, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStoragePublishFileResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		[MarshalAs(UnmanagedType.I1)]
		internal bool UserNeedsToAcceptWorkshopLegalAgreement;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStoragePublishFileResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStoragePublishFileResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageDeletePublishedFileResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageDeletePublishedFileResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageDeletePublishedFileResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageEnumerateUserPublishedFilesResult_t : ICallbackData
	{
		internal Result Result;

		internal int ResultsReturned;

		internal int TotalResultCount;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.U8)]
		internal PublishedFileId[] GPublishedFileId;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageEnumerateUserPublishedFilesResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageEnumerateUserPublishedFilesResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageSubscribePublishedFileResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageSubscribePublishedFileResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageSubscribePublishedFileResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageEnumerateUserSubscribedFilesResult_t : ICallbackData
	{
		internal Result Result;

		internal int ResultsReturned;

		internal int TotalResultCount;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.U8)]
		internal PublishedFileId[] GPublishedFileId;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.U4)]
		internal uint[] GRTimeSubscribed;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageEnumerateUserSubscribedFilesResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageEnumerateUserSubscribedFilesResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageUnsubscribePublishedFileResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageUnsubscribePublishedFileResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageUnsubscribePublishedFileResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageUpdatePublishedFileResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		[MarshalAs(UnmanagedType.I1)]
		internal bool UserNeedsToAcceptWorkshopLegalAgreement;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageUpdatePublishedFileResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageUpdatePublishedFileResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageDownloadUGCResult_t : ICallbackData
	{
		internal Result Result;

		internal ulong File;

		internal AppId AppID;

		internal int SizeInBytes;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 260)]
		internal byte[] PchFileName;

		internal ulong SteamIDOwner;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageDownloadUGCResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageDownloadUGCResult;

		internal string PchFileNameUTF8()
		{
			return Encoding.UTF8.GetString(PchFileName, 0, Array.IndexOf(PchFileName, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageGetPublishedFileDetailsResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		internal AppId CreatorAppID;

		internal AppId ConsumerAppID;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 129)]
		internal byte[] Title;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8000)]
		internal byte[] Description;

		internal ulong File;

		internal ulong PreviewFile;

		internal ulong SteamIDOwner;

		internal uint TimeCreated;

		internal uint TimeUpdated;

		internal RemoteStoragePublishedFileVisibility Visibility;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Banned;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1025)]
		internal byte[] Tags;

		[MarshalAs(UnmanagedType.I1)]
		internal bool TagsTruncated;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 260)]
		internal byte[] PchFileName;

		internal int FileSize;

		internal int PreviewFileSize;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
		internal byte[] URL;

		internal WorkshopFileType FileType;

		[MarshalAs(UnmanagedType.I1)]
		internal bool AcceptedForUse;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageGetPublishedFileDetailsResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageGetPublishedFileDetailsResult;

		internal string TitleUTF8()
		{
			return Encoding.UTF8.GetString(Title, 0, Array.IndexOf(Title, (byte)0));
		}

		internal string DescriptionUTF8()
		{
			return Encoding.UTF8.GetString(Description, 0, Array.IndexOf(Description, (byte)0));
		}

		internal string TagsUTF8()
		{
			return Encoding.UTF8.GetString(Tags, 0, Array.IndexOf(Tags, (byte)0));
		}

		internal string PchFileNameUTF8()
		{
			return Encoding.UTF8.GetString(PchFileName, 0, Array.IndexOf(PchFileName, (byte)0));
		}

		internal string URLUTF8()
		{
			return Encoding.UTF8.GetString(URL, 0, Array.IndexOf(URL, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageEnumerateWorkshopFilesResult_t : ICallbackData
	{
		internal Result Result;

		internal int ResultsReturned;

		internal int TotalResultCount;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.U8)]
		internal PublishedFileId[] GPublishedFileId;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.R4)]
		internal float[] GScore;

		internal AppId AppId;

		internal uint StartIndex;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageEnumerateWorkshopFilesResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageEnumerateWorkshopFilesResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageGetPublishedItemVoteDetailsResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		internal int VotesFor;

		internal int VotesAgainst;

		internal int Reports;

		internal float FScore;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageGetPublishedItemVoteDetailsResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageGetPublishedItemVoteDetailsResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStoragePublishedFileSubscribed_t : ICallbackData
	{
		internal PublishedFileId PublishedFileId;

		internal AppId AppID;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStoragePublishedFileSubscribed_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStoragePublishedFileSubscribed;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStoragePublishedFileUnsubscribed_t : ICallbackData
	{
		internal PublishedFileId PublishedFileId;

		internal AppId AppID;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStoragePublishedFileUnsubscribed_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStoragePublishedFileUnsubscribed;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStoragePublishedFileDeleted_t : ICallbackData
	{
		internal PublishedFileId PublishedFileId;

		internal AppId AppID;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStoragePublishedFileDeleted_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStoragePublishedFileDeleted;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageUpdateUserPublishedItemVoteResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageUpdateUserPublishedItemVoteResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageUpdateUserPublishedItemVoteResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageUserVoteDetails_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		internal WorkshopVote Vote;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageUserVoteDetails_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageUserVoteDetails;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageEnumerateUserSharedWorkshopFilesResult_t : ICallbackData
	{
		internal Result Result;

		internal int ResultsReturned;

		internal int TotalResultCount;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.U8)]
		internal PublishedFileId[] GPublishedFileId;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageEnumerateUserSharedWorkshopFilesResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageEnumerateUserSharedWorkshopFilesResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageSetUserPublishedFileActionResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		internal WorkshopFileAction Action;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageSetUserPublishedFileActionResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageSetUserPublishedFileActionResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageEnumeratePublishedFilesByUserActionResult_t : ICallbackData
	{
		internal Result Result;

		internal WorkshopFileAction Action;

		internal int ResultsReturned;

		internal int TotalResultCount;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.U8)]
		internal PublishedFileId[] GPublishedFileId;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.U4)]
		internal uint[] GRTimeUpdated;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageEnumeratePublishedFilesByUserActionResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStoragePublishFileProgress_t : ICallbackData
	{
		internal double DPercentFile;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Preview;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStoragePublishFileProgress_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStoragePublishFileProgress;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStoragePublishedFileUpdated_t : ICallbackData
	{
		internal PublishedFileId PublishedFileId;

		internal AppId AppID;

		internal ulong Unused;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStoragePublishedFileUpdated_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStoragePublishedFileUpdated;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageFileWriteAsyncComplete_t : ICallbackData
	{
		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageFileWriteAsyncComplete_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageFileWriteAsyncComplete;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoteStorageFileReadAsyncComplete_t : ICallbackData
	{
		internal ulong FileReadAsync;

		internal Result Result;

		internal uint Offset;

		internal uint Read;

		public static int _datasize = Marshal.SizeOf(typeof(RemoteStorageFileReadAsyncComplete_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoteStorageFileReadAsyncComplete;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct UserStatsReceived_t : ICallbackData
	{
		internal ulong GameID;

		internal Result Result;

		internal ulong SteamIDUser;

		public static int _datasize = Marshal.SizeOf(typeof(UserStatsReceived_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.UserStatsReceived;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct UserStatsStored_t : ICallbackData
	{
		internal ulong GameID;

		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(UserStatsStored_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.UserStatsStored;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct UserAchievementStored_t : ICallbackData
	{
		internal ulong GameID;

		[MarshalAs(UnmanagedType.I1)]
		internal bool GroupAchievement;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
		internal byte[] AchievementName;

		internal uint CurProgress;

		internal uint MaxProgress;

		public static int _datasize = Marshal.SizeOf(typeof(UserAchievementStored_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.UserAchievementStored;

		internal string AchievementNameUTF8()
		{
			return Encoding.UTF8.GetString(AchievementName, 0, Array.IndexOf(AchievementName, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LeaderboardFindResult_t : ICallbackData
	{
		internal ulong SteamLeaderboard;

		internal byte LeaderboardFound;

		public static int _datasize = Marshal.SizeOf(typeof(LeaderboardFindResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LeaderboardFindResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LeaderboardScoresDownloaded_t : ICallbackData
	{
		internal ulong SteamLeaderboard;

		internal ulong SteamLeaderboardEntries;

		internal int CEntryCount;

		public static int _datasize = Marshal.SizeOf(typeof(LeaderboardScoresDownloaded_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LeaderboardScoresDownloaded;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LeaderboardScoreUploaded_t : ICallbackData
	{
		internal byte Success;

		internal ulong SteamLeaderboard;

		internal int Score;

		internal byte ScoreChanged;

		internal int GlobalRankNew;

		internal int GlobalRankPrevious;

		public static int _datasize = Marshal.SizeOf(typeof(LeaderboardScoreUploaded_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LeaderboardScoreUploaded;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct NumberOfCurrentPlayers_t : ICallbackData
	{
		internal byte Success;

		internal int CPlayers;

		public static int _datasize = Marshal.SizeOf(typeof(NumberOfCurrentPlayers_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.NumberOfCurrentPlayers;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct UserStatsUnloaded_t : ICallbackData
	{
		internal ulong SteamIDUser;

		public static int _datasize = Marshal.SizeOf(typeof(UserStatsUnloaded_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.UserStatsUnloaded;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct UserAchievementIconFetched_t : ICallbackData
	{
		internal GameId GameID;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
		internal byte[] AchievementName;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Achieved;

		internal int IconHandle;

		public static int _datasize = Marshal.SizeOf(typeof(UserAchievementIconFetched_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.UserAchievementIconFetched;

		internal string AchievementNameUTF8()
		{
			return Encoding.UTF8.GetString(AchievementName, 0, Array.IndexOf(AchievementName, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GlobalAchievementPercentagesReady_t : ICallbackData
	{
		internal ulong GameID;

		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(GlobalAchievementPercentagesReady_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GlobalAchievementPercentagesReady;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LeaderboardUGCSet_t : ICallbackData
	{
		internal Result Result;

		internal ulong SteamLeaderboard;

		public static int _datasize = Marshal.SizeOf(typeof(LeaderboardUGCSet_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.LeaderboardUGCSet;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GlobalStatsReceived_t : ICallbackData
	{
		internal ulong GameID;

		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(GlobalStatsReceived_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GlobalStatsReceived;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct DlcInstalled_t : ICallbackData
	{
		internal AppId AppID;

		public static int _datasize = Marshal.SizeOf(typeof(DlcInstalled_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.DlcInstalled;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RegisterActivationCodeResponse_t : ICallbackData
	{
		internal RegisterActivationCodeResult Result;

		internal uint PackageRegistered;

		public static int _datasize = Marshal.SizeOf(typeof(RegisterActivationCodeResponse_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RegisterActivationCodeResponse;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct NewUrlLaunchParameters_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(NewUrlLaunchParameters_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.NewUrlLaunchParameters;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct AppProofOfPurchaseKeyResponse_t : ICallbackData
	{
		internal Result Result;

		internal uint AppID;

		internal uint CchKeyLength;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 240)]
		internal byte[] Key;

		public static int _datasize = Marshal.SizeOf(typeof(AppProofOfPurchaseKeyResponse_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.AppProofOfPurchaseKeyResponse;

		internal string KeyUTF8()
		{
			return Encoding.UTF8.GetString(Key, 0, Array.IndexOf(Key, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct FileDetailsResult_t : ICallbackData
	{
		internal Result Result;

		internal ulong FileSize;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)]
		internal byte[] FileSHA;

		internal uint Flags;

		public static int _datasize = Marshal.SizeOf(typeof(FileDetailsResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.FileDetailsResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct P2PSessionRequest_t : ICallbackData
	{
		internal ulong SteamIDRemote;

		public static int _datasize = Marshal.SizeOf(typeof(P2PSessionRequest_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.P2PSessionRequest;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct P2PSessionConnectFail_t : ICallbackData
	{
		internal ulong SteamIDRemote;

		internal byte P2PSessionError;

		public static int _datasize = Marshal.SizeOf(typeof(P2PSessionConnectFail_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.P2PSessionConnectFail;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct ScreenshotReady_t : ICallbackData
	{
		internal uint Local;

		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(ScreenshotReady_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.ScreenshotReady;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct ScreenshotRequested_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(ScreenshotRequested_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.ScreenshotRequested;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct PlaybackStatusHasChanged_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(PlaybackStatusHasChanged_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.PlaybackStatusHasChanged;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct VolumeHasChanged_t : ICallbackData
	{
		internal float NewVolume;

		public static int _datasize = Marshal.SizeOf(typeof(VolumeHasChanged_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.VolumeHasChanged;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MusicPlayerRemoteWillActivate_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(MusicPlayerRemoteWillActivate_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MusicPlayerRemoteWillActivate;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MusicPlayerRemoteWillDeactivate_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(MusicPlayerRemoteWillDeactivate_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MusicPlayerRemoteWillDeactivate;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MusicPlayerRemoteToFront_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(MusicPlayerRemoteToFront_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MusicPlayerRemoteToFront;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MusicPlayerWillQuit_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(MusicPlayerWillQuit_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MusicPlayerWillQuit;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MusicPlayerWantsPlay_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(MusicPlayerWantsPlay_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MusicPlayerWantsPlay;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MusicPlayerWantsPause_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(MusicPlayerWantsPause_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MusicPlayerWantsPause;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MusicPlayerWantsPlayPrevious_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(MusicPlayerWantsPlayPrevious_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MusicPlayerWantsPlayPrevious;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MusicPlayerWantsPlayNext_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(MusicPlayerWantsPlayNext_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MusicPlayerWantsPlayNext;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MusicPlayerWantsShuffled_t : ICallbackData
	{
		[MarshalAs(UnmanagedType.I1)]
		internal bool Shuffled;

		public static int _datasize = Marshal.SizeOf(typeof(MusicPlayerWantsShuffled_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MusicPlayerWantsShuffled;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MusicPlayerWantsLooped_t : ICallbackData
	{
		[MarshalAs(UnmanagedType.I1)]
		internal bool Looped;

		public static int _datasize = Marshal.SizeOf(typeof(MusicPlayerWantsLooped_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MusicPlayerWantsLooped;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MusicPlayerWantsVolume_t : ICallbackData
	{
		internal float NewVolume;

		public static int _datasize = Marshal.SizeOf(typeof(MusicPlayerWantsVolume_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MusicPlayerWantsVolume;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MusicPlayerSelectsQueueEntry_t : ICallbackData
	{
		internal int NID;

		public static int _datasize = Marshal.SizeOf(typeof(MusicPlayerSelectsQueueEntry_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MusicPlayerSelectsQueueEntry;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MusicPlayerSelectsPlaylistEntry_t : ICallbackData
	{
		internal int NID;

		public static int _datasize = Marshal.SizeOf(typeof(MusicPlayerSelectsPlaylistEntry_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MusicPlayerSelectsPlaylistEntry;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct MusicPlayerWantsPlayingRepeatStatus_t : ICallbackData
	{
		internal int PlayingRepeatStatus;

		public static int _datasize = Marshal.SizeOf(typeof(MusicPlayerWantsPlayingRepeatStatus_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.MusicPlayerWantsPlayingRepeatStatus;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTTPRequestCompleted_t : ICallbackData
	{
		internal uint Request;

		internal ulong ContextValue;

		[MarshalAs(UnmanagedType.I1)]
		internal bool RequestSuccessful;

		internal HTTPStatusCode StatusCode;

		internal uint BodySize;

		public static int _datasize = Marshal.SizeOf(typeof(HTTPRequestCompleted_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTTPRequestCompleted;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTTPRequestHeadersReceived_t : ICallbackData
	{
		internal uint Request;

		internal ulong ContextValue;

		public static int _datasize = Marshal.SizeOf(typeof(HTTPRequestHeadersReceived_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTTPRequestHeadersReceived;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTTPRequestDataReceived_t : ICallbackData
	{
		internal uint Request;

		internal ulong ContextValue;

		internal uint COffset;

		internal uint CBytesReceived;

		public static int _datasize = Marshal.SizeOf(typeof(HTTPRequestDataReceived_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTTPRequestDataReceived;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamUGCQueryCompleted_t : ICallbackData
	{
		internal ulong Handle;

		internal Result Result;

		internal uint NumResultsReturned;

		internal uint TotalMatchingResults;

		[MarshalAs(UnmanagedType.I1)]
		internal bool CachedData;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
		internal byte[] NextCursor;

		public static int _datasize = Marshal.SizeOf(typeof(SteamUGCQueryCompleted_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamUGCQueryCompleted;

		internal string NextCursorUTF8()
		{
			return Encoding.UTF8.GetString(NextCursor, 0, Array.IndexOf(NextCursor, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamUGCRequestUGCDetailsResult_t : ICallbackData
	{
		internal SteamUGCDetails_t Details;

		[MarshalAs(UnmanagedType.I1)]
		internal bool CachedData;

		public static int _datasize = Marshal.SizeOf(typeof(SteamUGCRequestUGCDetailsResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamUGCRequestUGCDetailsResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct CreateItemResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		[MarshalAs(UnmanagedType.I1)]
		internal bool UserNeedsToAcceptWorkshopLegalAgreement;

		public static int _datasize = Marshal.SizeOf(typeof(CreateItemResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.CreateItemResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SubmitItemUpdateResult_t : ICallbackData
	{
		internal Result Result;

		[MarshalAs(UnmanagedType.I1)]
		internal bool UserNeedsToAcceptWorkshopLegalAgreement;

		internal PublishedFileId PublishedFileId;

		public static int _datasize = Marshal.SizeOf(typeof(SubmitItemUpdateResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SubmitItemUpdateResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct ItemInstalled_t : ICallbackData
	{
		internal AppId AppID;

		internal PublishedFileId PublishedFileId;

		public static int _datasize = Marshal.SizeOf(typeof(ItemInstalled_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.ItemInstalled;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct DownloadItemResult_t : ICallbackData
	{
		internal AppId AppID;

		internal PublishedFileId PublishedFileId;

		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(DownloadItemResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.DownloadItemResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct UserFavoriteItemsListChanged_t : ICallbackData
	{
		internal PublishedFileId PublishedFileId;

		internal Result Result;

		[MarshalAs(UnmanagedType.I1)]
		internal bool WasAddRequest;

		public static int _datasize = Marshal.SizeOf(typeof(UserFavoriteItemsListChanged_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.UserFavoriteItemsListChanged;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SetUserItemVoteResult_t : ICallbackData
	{
		internal PublishedFileId PublishedFileId;

		internal Result Result;

		[MarshalAs(UnmanagedType.I1)]
		internal bool VoteUp;

		public static int _datasize = Marshal.SizeOf(typeof(SetUserItemVoteResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SetUserItemVoteResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GetUserItemVoteResult_t : ICallbackData
	{
		internal PublishedFileId PublishedFileId;

		internal Result Result;

		[MarshalAs(UnmanagedType.I1)]
		internal bool VotedUp;

		[MarshalAs(UnmanagedType.I1)]
		internal bool VotedDown;

		[MarshalAs(UnmanagedType.I1)]
		internal bool VoteSkipped;

		public static int _datasize = Marshal.SizeOf(typeof(GetUserItemVoteResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GetUserItemVoteResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct StartPlaytimeTrackingResult_t : ICallbackData
	{
		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(StartPlaytimeTrackingResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.StartPlaytimeTrackingResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct StopPlaytimeTrackingResult_t : ICallbackData
	{
		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(StopPlaytimeTrackingResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.StopPlaytimeTrackingResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct AddUGCDependencyResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		internal PublishedFileId ChildPublishedFileId;

		public static int _datasize = Marshal.SizeOf(typeof(AddUGCDependencyResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.AddUGCDependencyResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoveUGCDependencyResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		internal PublishedFileId ChildPublishedFileId;

		public static int _datasize = Marshal.SizeOf(typeof(RemoveUGCDependencyResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoveUGCDependencyResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct AddAppDependencyResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		internal AppId AppID;

		public static int _datasize = Marshal.SizeOf(typeof(AddAppDependencyResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.AddAppDependencyResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct RemoveAppDependencyResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		internal AppId AppID;

		public static int _datasize = Marshal.SizeOf(typeof(RemoveAppDependencyResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.RemoveAppDependencyResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GetAppDependenciesResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32, ArraySubType = UnmanagedType.U4)]
		internal AppId[] GAppIDs;

		internal uint NumAppDependencies;

		internal uint TotalNumAppDependencies;

		public static int _datasize = Marshal.SizeOf(typeof(GetAppDependenciesResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GetAppDependenciesResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct DeleteItemResult_t : ICallbackData
	{
		internal Result Result;

		internal PublishedFileId PublishedFileId;

		public static int _datasize = Marshal.SizeOf(typeof(DeleteItemResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.DeleteItemResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamAppInstalled_t : ICallbackData
	{
		internal AppId AppID;

		public static int _datasize = Marshal.SizeOf(typeof(SteamAppInstalled_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamAppInstalled;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamAppUninstalled_t : ICallbackData
	{
		internal AppId AppID;

		public static int _datasize = Marshal.SizeOf(typeof(SteamAppUninstalled_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamAppUninstalled;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_BrowserReady_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_BrowserReady_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_BrowserReady;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_NeedsPaint_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal string PBGRA;

		internal uint UnWide;

		internal uint UnTall;

		internal uint UnUpdateX;

		internal uint UnUpdateY;

		internal uint UnUpdateWide;

		internal uint UnUpdateTall;

		internal uint UnScrollX;

		internal uint UnScrollY;

		internal float FlPageScale;

		internal uint UnPageSerial;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_NeedsPaint_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_NeedsPaint;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_StartRequest_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal string PchURL;

		internal string PchTarget;

		internal string PchPostData;

		[MarshalAs(UnmanagedType.I1)]
		internal bool BIsRedirect;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_StartRequest_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_StartRequest;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_CloseBrowser_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_CloseBrowser_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_CloseBrowser;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_URLChanged_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal string PchURL;

		internal string PchPostData;

		[MarshalAs(UnmanagedType.I1)]
		internal bool BIsRedirect;

		internal string PchPageTitle;

		[MarshalAs(UnmanagedType.I1)]
		internal bool BNewNavigation;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_URLChanged_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_URLChanged;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_FinishedRequest_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal string PchURL;

		internal string PchPageTitle;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_FinishedRequest_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_FinishedRequest;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_OpenLinkInNewTab_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal string PchURL;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_OpenLinkInNewTab_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_OpenLinkInNewTab;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_ChangedTitle_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal string PchTitle;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_ChangedTitle_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_ChangedTitle;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_SearchResults_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal uint UnResults;

		internal uint UnCurrentMatch;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_SearchResults_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_SearchResults;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_CanGoBackAndForward_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		[MarshalAs(UnmanagedType.I1)]
		internal bool BCanGoBack;

		[MarshalAs(UnmanagedType.I1)]
		internal bool BCanGoForward;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_CanGoBackAndForward_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_CanGoBackAndForward;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_HorizontalScroll_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal uint UnScrollMax;

		internal uint UnScrollCurrent;

		internal float FlPageScale;

		[MarshalAs(UnmanagedType.I1)]
		internal bool BVisible;

		internal uint UnPageSize;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_HorizontalScroll_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_HorizontalScroll;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_VerticalScroll_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal uint UnScrollMax;

		internal uint UnScrollCurrent;

		internal float FlPageScale;

		[MarshalAs(UnmanagedType.I1)]
		internal bool BVisible;

		internal uint UnPageSize;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_VerticalScroll_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_VerticalScroll;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_LinkAtPosition_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal uint X;

		internal uint Y;

		internal string PchURL;

		[MarshalAs(UnmanagedType.I1)]
		internal bool BInput;

		[MarshalAs(UnmanagedType.I1)]
		internal bool BLiveLink;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_LinkAtPosition_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_LinkAtPosition;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_JSAlert_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal string PchMessage;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_JSAlert_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_JSAlert;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_JSConfirm_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal string PchMessage;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_JSConfirm_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_JSConfirm;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_FileOpenDialog_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal string PchTitle;

		internal string PchInitialFile;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_FileOpenDialog_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_FileOpenDialog;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_NewWindow_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal string PchURL;

		internal uint UnX;

		internal uint UnY;

		internal uint UnWide;

		internal uint UnTall;

		internal uint UnNewWindow_BrowserHandle_IGNORE;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_NewWindow_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_NewWindow;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_SetCursor_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal uint EMouseCursor;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_SetCursor_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_SetCursor;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_StatusText_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal string PchMsg;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_StatusText_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_StatusText;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_ShowToolTip_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal string PchMsg;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_ShowToolTip_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_ShowToolTip;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_UpdateToolTip_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal string PchMsg;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_UpdateToolTip_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_UpdateToolTip;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_HideToolTip_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_HideToolTip_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_HideToolTip;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct HTML_BrowserRestarted_t : ICallbackData
	{
		internal uint UnBrowserHandle;

		internal uint UnOldBrowserHandle;

		public static int _datasize = Marshal.SizeOf(typeof(HTML_BrowserRestarted_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.HTML_BrowserRestarted;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamInventoryResultReady_t : ICallbackData
	{
		internal int Handle;

		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(SteamInventoryResultReady_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamInventoryResultReady;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamInventoryFullUpdate_t : ICallbackData
	{
		internal int Handle;

		public static int _datasize = Marshal.SizeOf(typeof(SteamInventoryFullUpdate_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamInventoryFullUpdate;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamInventoryDefinitionUpdate_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(SteamInventoryDefinitionUpdate_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamInventoryDefinitionUpdate;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct SteamInventoryEligiblePromoItemDefIDs_t : ICallbackData
	{
		internal Result Result;

		internal ulong SteamID;

		internal int UmEligiblePromoItemDefs;

		[MarshalAs(UnmanagedType.I1)]
		internal bool CachedData;

		public static int _datasize = Marshal.SizeOf(typeof(SteamInventoryEligiblePromoItemDefIDs_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamInventoryEligiblePromoItemDefIDs;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamInventoryStartPurchaseResult_t : ICallbackData
	{
		internal Result Result;

		internal ulong OrderID;

		internal ulong TransID;

		public static int _datasize = Marshal.SizeOf(typeof(SteamInventoryStartPurchaseResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamInventoryStartPurchaseResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamInventoryRequestPricesResult_t : ICallbackData
	{
		internal Result Result;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
		internal byte[] Currency;

		public static int _datasize = Marshal.SizeOf(typeof(SteamInventoryRequestPricesResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamInventoryRequestPricesResult;

		internal string CurrencyUTF8()
		{
			return Encoding.UTF8.GetString(Currency, 0, Array.IndexOf(Currency, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GetVideoURLResult_t : ICallbackData
	{
		internal Result Result;

		internal AppId VideoAppID;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
		internal byte[] URL;

		public static int _datasize = Marshal.SizeOf(typeof(GetVideoURLResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GetVideoURLResult;

		internal string URLUTF8()
		{
			return Encoding.UTF8.GetString(URL, 0, Array.IndexOf(URL, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GetOPFSettingsResult_t : ICallbackData
	{
		internal Result Result;

		internal AppId VideoAppID;

		public static int _datasize = Marshal.SizeOf(typeof(GetOPFSettingsResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GetOPFSettingsResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct BroadcastUploadStart_t : ICallbackData
	{
		[MarshalAs(UnmanagedType.I1)]
		internal bool IsRTMP;

		public static int _datasize = Marshal.SizeOf(typeof(BroadcastUploadStart_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.BroadcastUploadStart;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct BroadcastUploadStop_t : ICallbackData
	{
		internal BroadcastUploadResult Result;

		public static int _datasize = Marshal.SizeOf(typeof(BroadcastUploadStop_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.BroadcastUploadStop;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamParentalSettingsChanged_t : ICallbackData
	{
		public static int _datasize = Marshal.SizeOf(typeof(SteamParentalSettingsChanged_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamParentalSettingsChanged;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamRemotePlaySessionConnected_t : ICallbackData
	{
		internal uint SessionID;

		public static int _datasize = Marshal.SizeOf(typeof(SteamRemotePlaySessionConnected_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamRemotePlaySessionConnected;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamRemotePlaySessionDisconnected_t : ICallbackData
	{
		internal uint SessionID;

		public static int _datasize = Marshal.SizeOf(typeof(SteamRemotePlaySessionDisconnected_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamRemotePlaySessionDisconnected;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamNetConnectionStatusChangedCallback_t : ICallbackData
	{
		internal Connection Conn;

		internal ConnectionInfo Nfo;

		internal ConnectionState OldState;

		public static int _datasize = Marshal.SizeOf(typeof(SteamNetConnectionStatusChangedCallback_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamNetConnectionStatusChangedCallback;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamNetAuthenticationStatus_t : ICallbackData
	{
		internal SteamNetworkingAvailability Avail;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
		internal byte[] DebugMsg;

		public static int _datasize = Marshal.SizeOf(typeof(SteamNetAuthenticationStatus_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamNetAuthenticationStatus;

		internal string DebugMsgUTF8()
		{
			return Encoding.UTF8.GetString(DebugMsg, 0, Array.IndexOf(DebugMsg, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamRelayNetworkStatus_t : ICallbackData
	{
		internal SteamNetworkingAvailability Avail;

		internal int PingMeasurementInProgress;

		internal SteamNetworkingAvailability AvailNetworkConfig;

		internal SteamNetworkingAvailability AvailAnyRelay;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
		internal byte[] DebugMsg;

		public static int _datasize = Marshal.SizeOf(typeof(SteamRelayNetworkStatus_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.SteamRelayNetworkStatus;

		internal string DebugMsgUTF8()
		{
			return Encoding.UTF8.GetString(DebugMsg, 0, Array.IndexOf(DebugMsg, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct GSClientApprove_t : ICallbackData
	{
		internal ulong SteamID;

		internal ulong OwnerSteamID;

		public static int _datasize = Marshal.SizeOf(typeof(GSClientApprove_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GSClientApprove;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GSClientDeny_t : ICallbackData
	{
		internal ulong SteamID;

		internal DenyReason DenyReason;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
		internal byte[] OptionalText;

		public static int _datasize = Marshal.SizeOf(typeof(GSClientDeny_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GSClientDeny;

		internal string OptionalTextUTF8()
		{
			return Encoding.UTF8.GetString(OptionalText, 0, Array.IndexOf(OptionalText, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GSClientKick_t : ICallbackData
	{
		internal ulong SteamID;

		internal DenyReason DenyReason;

		public static int _datasize = Marshal.SizeOf(typeof(GSClientKick_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GSClientKick;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GSClientAchievementStatus_t : ICallbackData
	{
		internal ulong SteamID;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
		internal byte[] PchAchievement;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Unlocked;

		public static int _datasize = Marshal.SizeOf(typeof(GSClientAchievementStatus_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GSClientAchievementStatus;

		internal string PchAchievementUTF8()
		{
			return Encoding.UTF8.GetString(PchAchievement, 0, Array.IndexOf(PchAchievement, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GSPolicyResponse_t : ICallbackData
	{
		internal byte Secure;

		public static int _datasize = Marshal.SizeOf(typeof(GSPolicyResponse_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GSPolicyResponse;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GSGameplayStats_t : ICallbackData
	{
		internal Result Result;

		internal int Rank;

		internal uint TotalConnects;

		internal uint TotalMinutesPlayed;

		public static int _datasize = Marshal.SizeOf(typeof(GSGameplayStats_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GSGameplayStats;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct GSClientGroupStatus_t : ICallbackData
	{
		internal ulong SteamIDUser;

		internal ulong SteamIDGroup;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Member;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Officer;

		public static int _datasize = Marshal.SizeOf(typeof(GSClientGroupStatus_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GSClientGroupStatus;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GSReputation_t : ICallbackData
	{
		internal Result Result;

		internal uint ReputationScore;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Banned;

		internal uint BannedIP;

		internal ushort BannedPort;

		internal ulong BannedGameID;

		internal uint BanExpires;

		public static int _datasize = Marshal.SizeOf(typeof(GSReputation_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GSReputation;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct AssociateWithClanResult_t : ICallbackData
	{
		internal Result Result;

		public static int _datasize = Marshal.SizeOf(typeof(AssociateWithClanResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.AssociateWithClanResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct ComputeNewPlayerCompatibilityResult_t : ICallbackData
	{
		internal Result Result;

		internal int CPlayersThatDontLikeCandidate;

		internal int CPlayersThatCandidateDoesntLike;

		internal int CClanPlayersThatDontLikeCandidate;

		internal ulong SteamIDCandidate;

		public static int _datasize = Marshal.SizeOf(typeof(ComputeNewPlayerCompatibilityResult_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.ComputeNewPlayerCompatibilityResult;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct GSStatsReceived_t : ICallbackData
	{
		internal Result Result;

		internal ulong SteamIDUser;

		public static int _datasize = Marshal.SizeOf(typeof(GSStatsReceived_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GSStatsReceived;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct GSStatsStored_t : ICallbackData
	{
		internal Result Result;

		internal ulong SteamIDUser;

		public static int _datasize = Marshal.SizeOf(typeof(GSStatsStored_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.GSStatsStored;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct GSStatsUnloaded_t : ICallbackData
	{
		internal ulong SteamIDUser;

		public static int _datasize = Marshal.SizeOf(typeof(GSStatsUnloaded_t));

		public int DataSize => _datasize;

		public CallbackType CallbackType => CallbackType.UserStatsUnloaded;
	}
	internal static class Defines
	{
		internal static readonly int k_cubSaltSize = 8;

		internal static readonly GID_t k_GIDNil = ulong.MaxValue;

		internal static readonly GID_t k_TxnIDNil = k_GIDNil;

		internal static readonly GID_t k_TxnIDUnknown = 0uL;

		internal static readonly JobID_t k_JobIDNil = ulong.MaxValue;

		internal static readonly PackageId_t k_uPackageIdInvalid = uint.MaxValue;

		internal static readonly BundleId_t k_uBundleIdInvalid = 0u;

		internal static readonly AppId k_uAppIdInvalid = 0;

		internal static readonly AssetClassId_t k_ulAssetClassIdInvalid = 0uL;

		internal static readonly PhysicalItemId_t k_uPhysicalItemIdInvalid = 0u;

		internal static readonly DepotId_t k_uDepotIdInvalid = 0u;

		internal static readonly CellID_t k_uCellIDInvalid = uint.MaxValue;

		internal static readonly SteamAPICall_t k_uAPICallInvalid = 0uL;

		internal static readonly PartnerId_t k_uPartnerIdInvalid = 0u;

		internal static readonly ManifestId_t k_uManifestIdInvalid = 0uL;

		internal static readonly SiteId_t k_ulSiteIdInvalid = 0uL;

		internal static readonly PartyBeaconID_t k_ulPartyBeaconIdInvalid = 0uL;

		internal static readonly HAuthTicket k_HAuthTicketInvalid = 0u;

		internal static readonly uint k_unSteamAccountIDMask = uint.MaxValue;

		internal static readonly uint k_unSteamAccountInstanceMask = 1048575u;

		internal static readonly uint k_unSteamUserDefaultInstance = 1u;

		internal static readonly int k_cchGameExtraInfoMax = 64;

		internal static readonly int k_cchMaxFriendsGroupName = 64;

		internal static readonly int k_cFriendsGroupLimit = 100;

		internal static readonly FriendsGroupID_t k_FriendsGroupID_Invalid = (short)(-1);

		internal static readonly int k_cEnumerateFollowersMax = 50;

		internal static readonly uint k_cubChatMetadataMax = 8192u;

		internal static readonly int k_cbMaxGameServerGameDir = 32;

		internal static readonly int k_cbMaxGameServerMapName = 32;

		internal static readonly int k_cbMaxGameServerGameDescription = 64;

		internal static readonly int k_cbMaxGameServerName = 64;

		internal static readonly int k_cbMaxGameServerTags = 128;

		internal static readonly int k_cbMaxGameServerGameData = 2048;

		internal static readonly int HSERVERQUERY_INVALID = -1;

		internal static readonly uint k_unFavoriteFlagNone = 0u;

		internal static readonly uint k_unFavoriteFlagFavorite = 1u;

		internal static readonly uint k_unFavoriteFlagHistory = 2u;

		internal static readonly uint k_unMaxCloudFileChunkSize = 104857600u;

		internal static readonly PublishedFileId k_PublishedFileIdInvalid = 0uL;

		internal static readonly UGCHandle_t k_UGCHandleInvalid = ulong.MaxValue;

		internal static readonly PublishedFileUpdateHandle_t k_PublishedFileUpdateHandleInvalid = ulong.MaxValue;

		internal static readonly UGCFileWriteStreamHandle_t k_UGCFileStreamHandleInvalid = ulong.MaxValue;

		internal static readonly uint k_cchPublishedDocumentTitleMax = 129u;

		internal static readonly uint k_cchPublishedDocumentDescriptionMax = 8000u;

		internal static readonly uint k_cchPublishedDocumentChangeDescriptionMax = 8000u;

		internal static readonly uint k_unEnumeratePublishedFilesMaxResults = 50u;

		internal static readonly uint k_cchTagListMax = 1025u;

		internal static readonly uint k_cchFilenameMax = 260u;

		internal static readonly uint k_cchPublishedFileURLMax = 256u;

		internal static readonly int k_cubAppProofOfPurchaseKeyMax = 240;

		internal static readonly uint k_nScreenshotMaxTaggedUsers = 32u;

		internal static readonly uint k_nScreenshotMaxTaggedPublishedFiles = 32u;

		internal static readonly int k_cubUFSTagTypeMax = 255;

		internal static readonly int k_cubUFSTagValueMax = 255;

		internal static readonly int k_ScreenshotThumbWidth = 200;

		internal static readonly UGCQueryHandle_t k_UGCQueryHandleInvalid = ulong.MaxValue;

		internal static readonly UGCUpdateHandle_t k_UGCUpdateHandleInvalid = ulong.MaxValue;

		internal static readonly uint kNumUGCResultsPerPage = 50u;

		internal static readonly uint k_cchDeveloperMetadataMax = 5000u;

		internal static readonly uint INVALID_HTMLBROWSER = 0u;

		internal static readonly InventoryItemId k_SteamItemInstanceIDInvalid = ulong.MaxValue;

		internal static readonly SteamInventoryResult_t k_SteamInventoryResultInvalid = -1;

		internal static readonly SteamInventoryUpdateHandle_t k_SteamInventoryUpdateHandleInvalid = ulong.MaxValue;

		internal static readonly Connection k_HSteamNetConnection_Invalid = 0u;

		internal static readonly Socket k_HSteamListenSocket_Invalid = 0u;

		internal static readonly HSteamNetPollGroup k_HSteamNetPollGroup_Invalid = 0u;

		internal static readonly int k_cchMaxSteamNetworkingErrMsg = 1024;

		internal static readonly int k_cchSteamNetworkingMaxConnectionCloseReason = 128;

		internal static readonly int k_cchSteamNetworkingMaxConnectionDescription = 128;

		internal static readonly int k_cbMaxSteamNetworkingSocketsMessageSizeSend = 524288;

		internal static readonly int k_nSteamNetworkingSend_Unreliable = 0;

		internal static readonly int k_nSteamNetworkingSend_NoNagle = 1;

		internal static readonly int k_nSteamNetworkingSend_UnreliableNoNagle = k_nSteamNetworkingSend_Unreliable | k_nSteamNetworkingSend_NoNagle;

		internal static readonly int k_nSteamNetworkingSend_NoDelay = 4;

		internal static readonly int k_nSteamNetworkingSend_UnreliableNoDelay = k_nSteamNetworkingSend_Unreliable | k_nSteamNetworkingSend_NoDelay | k_nSteamNetworkingSend_NoNagle;

		internal static readonly int k_nSteamNetworkingSend_Reliable = 8;

		internal static readonly int k_nSteamNetworkingSend_ReliableNoNagle = k_nSteamNetworkingSend_Reliable | k_nSteamNetworkingSend_NoNagle;

		internal static readonly int k_nSteamNetworkingSend_UseCurrentThread = 16;

		internal static readonly int k_cchMaxSteamNetworkingPingLocationString = 1024;

		internal static readonly int k_nSteamNetworkingPing_Failed = -1;

		internal static readonly int k_nSteamNetworkingPing_Unknown = -2;

		internal static readonly SteamNetworkingPOPID k_SteamDatagramPOPID_dev = 6579574u;

		internal static readonly uint k_unServerFlagNone = 0u;

		internal static readonly uint k_unServerFlagActive = 1u;

		internal static readonly uint k_unServerFlagSecure = 2u;

		internal static readonly uint k_unServerFlagDedicated = 4u;

		internal static readonly uint k_unServerFlagLinux = 8u;

		internal static readonly uint k_unServerFlagPassworded = 16u;

		internal static readonly uint k_unServerFlagPrivate = 32u;

		internal static readonly uint k_cbSteamDatagramMaxSerializedTicket = 512u;

		internal static readonly uint k_cbMaxSteamDatagramGameCoordinatorServerLoginAppData = 2048u;

		internal static readonly uint k_cbMaxSteamDatagramGameCoordinatorServerLoginSerialized = 4096u;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct gameserveritem_t
	{
		internal servernetadr_t NetAdr;

		internal int Ping;

		[MarshalAs(UnmanagedType.I1)]
		internal bool HadSuccessfulResponse;

		[MarshalAs(UnmanagedType.I1)]
		internal bool DoNotRefresh;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
		internal byte[] GameDir;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
		internal byte[] Map;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
		internal byte[] GameDescription;

		internal uint AppID;

		internal int Players;

		internal int MaxPlayers;

		internal int BotPlayers;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Password;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Secure;

		internal uint TimeLastPlayed;

		internal int ServerVersion;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
		internal byte[] ServerName;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
		internal byte[] GameTags;

		internal ulong SteamID;

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_gameserveritem_t_Construct")]
		internal static extern void InternalConstruct(ref gameserveritem_t self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_gameserveritem_t_GetName")]
		internal static extern Utf8StringPointer InternalGetName(ref gameserveritem_t self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_gameserveritem_t_SetName")]
		internal static extern void InternalSetName(ref gameserveritem_t self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pName);

		internal string GameDirUTF8()
		{
			return Encoding.UTF8.GetString(GameDir, 0, Array.IndexOf(GameDir, (byte)0));
		}

		internal string MapUTF8()
		{
			return Encoding.UTF8.GetString(Map, 0, Array.IndexOf(Map, (byte)0));
		}

		internal string GameDescriptionUTF8()
		{
			return Encoding.UTF8.GetString(GameDescription, 0, Array.IndexOf(GameDescription, (byte)0));
		}

		internal string ServerNameUTF8()
		{
			return Encoding.UTF8.GetString(ServerName, 0, Array.IndexOf(ServerName, (byte)0));
		}

		internal string GameTagsUTF8()
		{
			return Encoding.UTF8.GetString(GameTags, 0, Array.IndexOf(GameTags, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct MatchMakingKeyValuePair
	{
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
		internal string Key;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
		internal string Value;

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_MatchMakingKeyValuePair_t_Construct")]
		internal static extern void InternalConstruct(ref MatchMakingKeyValuePair self);
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct servernetadr_t
	{
		internal ushort ConnectionPort;

		internal ushort QueryPort;

		internal uint IP;

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_servernetadr_t_Construct")]
		internal static extern void InternalConstruct(ref servernetadr_t self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_servernetadr_t_Init")]
		internal static extern void InternalInit(ref servernetadr_t self, uint ip, ushort usQueryPort, ushort usConnectionPort);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_servernetadr_t_GetQueryPort")]
		internal static extern ushort InternalGetQueryPort(ref servernetadr_t self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_servernetadr_t_SetQueryPort")]
		internal static extern void InternalSetQueryPort(ref servernetadr_t self, ushort usPort);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_servernetadr_t_GetConnectionPort")]
		internal static extern ushort InternalGetConnectionPort(ref servernetadr_t self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_servernetadr_t_SetConnectionPort")]
		internal static extern void InternalSetConnectionPort(ref servernetadr_t self, ushort usPort);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_servernetadr_t_GetIP")]
		internal static extern uint InternalGetIP(ref servernetadr_t self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_servernetadr_t_SetIP")]
		internal static extern void InternalSetIP(ref servernetadr_t self, uint unIP);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_servernetadr_t_GetConnectionAddressString")]
		internal static extern Utf8StringPointer InternalGetConnectionAddressString(ref servernetadr_t self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_servernetadr_t_GetQueryAddressString")]
		internal static extern Utf8StringPointer InternalGetQueryAddressString(ref servernetadr_t self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_servernetadr_t_IsLessThan")]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool InternalIsLessThan(ref servernetadr_t self, ref servernetadr_t netadr);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_servernetadr_t_Assign")]
		internal static extern void InternalAssign(ref servernetadr_t self, ref servernetadr_t that);
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamDatagramHostedAddress
	{
		internal int CbSize;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
		internal byte[] Data;

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamDatagramHostedAddress_Clear")]
		internal static extern void InternalClear(ref SteamDatagramHostedAddress self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamDatagramHostedAddress_GetPopID")]
		internal static extern SteamNetworkingPOPID InternalGetPopID(ref SteamDatagramHostedAddress self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamDatagramHostedAddress_SetDevAddress")]
		internal static extern void InternalSetDevAddress(ref SteamDatagramHostedAddress self, uint nIP, ushort nPort, SteamNetworkingPOPID popid);

		internal string DataUTF8()
		{
			return Encoding.UTF8.GetString(Data, 0, Array.IndexOf(Data, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Explicit, Pack = 8)]
	internal struct SteamIPAddress
	{
		[FieldOffset(0)]
		public uint Ip4Address;

		[FieldOffset(16)]
		internal SteamIPType Type;

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamIPAddress_t_IsSet")]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool InternalIsSet(ref SteamIPAddress self);

		public static implicit operator IPAddress(SteamIPAddress value)
		{
			if (value.Type == SteamIPType.Type4)
			{
				return Utility.Int32ToIp(value.Ip4Address);
			}
			throw new Exception($"Oops - can't convert SteamIPAddress to System.Net.IPAddress because no-one coded support for {value.Type} yet");
		}
	}
	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 136)]
	public struct NetIdentity
	{
		internal enum IdentityType
		{
			Invalid = 0,
			IPAddress = 1,
			GenericString = 2,
			GenericBytes = 3,
			SteamID = 16
		}

		[FieldOffset(0)]
		internal IdentityType type;

		[FieldOffset(4)]
		internal int size;

		[FieldOffset(8)]
		internal ulong steamid;

		[FieldOffset(8)]
		internal NetAddress netaddress;

		public static NetIdentity LocalHost
		{
			get
			{
				NetIdentity self = default(NetIdentity);
				InternalSetLocalHost(ref self);
				return self;
			}
		}

		public bool IsSteamId => type == IdentityType.SteamID;

		public bool IsIpAddress => type == IdentityType.IPAddress;

		public bool IsLocalHost
		{
			get
			{
				NetIdentity self = default(NetIdentity);
				return InternalIsLocalHost(ref self);
			}
		}

		public SteamId SteamId
		{
			get
			{
				if (type != IdentityType.SteamID)
				{
					return default(SteamId);
				}
				NetIdentity self = this;
				return InternalGetSteamID(ref self);
			}
		}

		public NetAddress Address
		{
			get
			{
				if (type != IdentityType.IPAddress)
				{
					return default(NetAddress);
				}
				NetIdentity self = this;
				return InternalGetIPAddr(ref self).ToType<NetAddress>();
			}
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_Clear")]
		internal static extern void InternalClear(ref NetIdentity self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_IsInvalid")]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool InternalIsInvalid(ref NetIdentity self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_SetSteamID")]
		internal static extern void InternalSetSteamID(ref NetIdentity self, SteamId steamID);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_GetSteamID")]
		internal static extern SteamId InternalGetSteamID(ref NetIdentity self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_SetSteamID64")]
		internal static extern void InternalSetSteamID64(ref NetIdentity self, ulong steamID);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_GetSteamID64")]
		internal static extern ulong InternalGetSteamID64(ref NetIdentity self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_SetXboxPairwiseID")]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool InternalSetXboxPairwiseID(ref NetIdentity self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszString);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_GetXboxPairwiseID")]
		internal static extern Utf8StringPointer InternalGetXboxPairwiseID(ref NetIdentity self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_SetIPAddr")]
		internal static extern void InternalSetIPAddr(ref NetIdentity self, ref NetAddress addr);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_GetIPAddr")]
		internal static extern IntPtr InternalGetIPAddr(ref NetIdentity self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_SetLocalHost")]
		internal static extern void InternalSetLocalHost(ref NetIdentity self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_IsLocalHost")]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool InternalIsLocalHost(ref NetIdentity self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_SetGenericString")]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool InternalSetGenericString(ref NetIdentity self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszString);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_GetGenericString")]
		internal static extern Utf8StringPointer InternalGetGenericString(ref NetIdentity self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_SetGenericBytes")]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool InternalSetGenericBytes(ref NetIdentity self, IntPtr data, uint cbLen);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_GetGenericBytes")]
		internal static extern byte InternalGetGenericBytes(ref NetIdentity self, ref int cbLen);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_IsEqualTo")]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool InternalIsEqualTo(ref NetIdentity self, ref NetIdentity x);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_ToString")]
		internal static extern void InternalToString(ref NetIdentity self, IntPtr buf, uint cbBuf);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIdentity_ParseString")]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool InternalParseString(ref NetIdentity self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszStr);

		public static implicit operator NetIdentity(SteamId value)
		{
			NetIdentity self = default(NetIdentity);
			InternalSetSteamID(ref self, value);
			return self;
		}

		public static implicit operator NetIdentity(NetAddress address)
		{
			NetIdentity self = default(NetIdentity);
			InternalSetIPAddr(ref self, ref address);
			return self;
		}

		public static implicit operator SteamId(NetIdentity value)
		{
			return value.SteamId;
		}

		public override string ToString()
		{
			NetIdentity identity = this;
			SteamNetworkingUtils.Internal.SteamNetworkingIdentity_ToString(ref identity, out var buf);
			return buf;
		}
	}
	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 18)]
	public struct NetAddress
	{
		internal struct IPV4
		{
			internal ulong m_8zeros;

			internal ushort m_0000;

			internal ushort m_ffff;

			internal byte ip0;

			internal byte ip1;

			internal byte ip2;

			internal byte ip3;
		}

		[FieldOffset(0)]
		internal IPV4 ip;

		[FieldOffset(16)]
		internal ushort port;

		public ushort Port => port;

		public static NetAddress Cleared
		{
			get
			{
				NetAddress self = default(NetAddress);
				InternalClear(ref self);
				return self;
			}
		}

		public bool IsIPv6AllZeros
		{
			get
			{
				NetAddress self = this;
				return InternalIsIPv6AllZeros(ref self);
			}
		}

		public bool IsIPv4
		{
			get
			{
				NetAddress self = this;
				return InternalIsIPv4(ref self);
			}
		}

		public bool IsLocalHost
		{
			get
			{
				NetAddress self = this;
				return InternalIsLocalHost(ref self);
			}
		}

		public IPAddress Address
		{
			get
			{
				if (IsIPv4)
				{
					NetAddress self = this;
					return Utility.Int32ToIp(InternalGetIPv4(ref self));
				}
				throw new NotImplementedException("Oops - no IPV6 support yet?");
			}
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIPAddr_Clear")]
		internal static extern void InternalClear(ref NetAddress self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIPAddr_IsIPv6AllZeros")]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool InternalIsIPv6AllZeros(ref NetAddress self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIPAddr_SetIPv6")]
		internal static extern void InternalSetIPv6(ref NetAddress self, ref byte ipv6, ushort nPort);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIPAddr_SetIPv4")]
		internal static extern void InternalSetIPv4(ref NetAddress self, uint nIP, ushort nPort);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIPAddr_IsIPv4")]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool InternalIsIPv4(ref NetAddress self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIPAddr_GetIPv4")]
		internal static extern uint InternalGetIPv4(ref NetAddress self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost")]
		internal static extern void InternalSetIPv6LocalHost(ref NetAddress self, ushort nPort);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIPAddr_IsLocalHost")]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool InternalIsLocalHost(ref NetAddress self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIPAddr_ToString")]
		internal static extern void InternalToString(ref NetAddress self, IntPtr buf, uint cbBuf, [MarshalAs(UnmanagedType.U1)] bool bWithPort);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIPAddr_ParseString")]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool InternalParseString(ref NetAddress self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszStr);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingIPAddr_IsEqualTo")]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool InternalIsEqualTo(ref NetAddress self, ref NetAddress x);

		public static NetAddress AnyIp(ushort port)
		{
			NetAddress cleared = Cleared;
			cleared.port = port;
			return cleared;
		}

		public static NetAddress LocalHost(ushort port)
		{
			NetAddress self = Cleared;
			InternalSetIPv6LocalHost(ref self, port);
			return self;
		}

		public static NetAddress From(string addrStr, ushort port)
		{
			return From(IPAddress.Parse(addrStr), port);
		}

		public static NetAddress From(IPAddress address, ushort port)
		{
			address.GetAddressBytes();
			if (address.AddressFamily == AddressFamily.InterNetwork)
			{
				NetAddress self = Cleared;
				InternalSetIPv4(ref self, address.IpToInt32(), port);
				return self;
			}
			throw new NotImplementedException("Oops - no IPV6 support yet?");
		}

		public override string ToString()
		{
			IntPtr intPtr = Helpers.TakeMemory();
			NetAddress self = this;
			InternalToString(ref self, intPtr, 32768u, bWithPort: true);
			return Helpers.MemoryToString(intPtr);
		}
	}
	internal struct NetMsg
	{
		internal IntPtr DataPtr;

		internal int DataSize;

		internal Connection Connection;

		internal NetIdentity Identity;

		internal long ConnectionUserData;

		internal long RecvTime;

		internal long MessageNumber;

		internal IntPtr FreeDataPtr;

		internal IntPtr ReleasePtr;

		internal int Channel;

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_SteamNetworkingMessage_t_Release")]
		internal unsafe static extern void InternalRelease(NetMsg* self);
	}
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct FriendGameInfo_t
	{
		internal GameId GameID;

		internal uint GameIP;

		internal ushort GamePort;

		internal ushort QueryPort;

		internal ulong SteamIDLobby;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct FriendSessionStateInfo_t
	{
		internal uint IOnlineSessionInstances;

		internal byte IPublishedToFriendsSessionInstance;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamPartyBeaconLocation_t
	{
		internal SteamPartyBeaconLocationType Type;

		internal ulong LocationID;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamParamStringArray_t
	{
		internal IntPtr Strings;

		internal int NumStrings;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct LeaderboardEntry_t
	{
		internal ulong SteamIDUser;

		internal int GlobalRank;

		internal int Score;

		internal int CDetails;

		internal ulong UGC;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct P2PSessionState_t
	{
		internal byte ConnectionActive;

		internal byte Connecting;

		internal byte P2PSessionError;

		internal byte UsingRelay;

		internal int BytesQueuedForSend;

		internal int PacketsQueuedForSend;

		internal uint RemoteIP;

		internal ushort RemotePort;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamUGCDetails_t
	{
		internal PublishedFileId PublishedFileId;

		internal Result Result;

		internal WorkshopFileType FileType;

		internal AppId CreatorAppID;

		internal AppId ConsumerAppID;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 129)]
		internal byte[] Title;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8000)]
		internal byte[] Description;

		internal ulong SteamIDOwner;

		internal uint TimeCreated;

		internal uint TimeUpdated;

		internal uint TimeAddedToUserList;

		internal RemoteStoragePublishedFileVisibility Visibility;

		[MarshalAs(UnmanagedType.I1)]
		internal bool Banned;

		[MarshalAs(UnmanagedType.I1)]
		internal bool AcceptedForUse;

		[MarshalAs(UnmanagedType.I1)]
		internal bool TagsTruncated;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1025)]
		internal byte[] Tags;

		internal ulong File;

		internal ulong PreviewFile;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 260)]
		internal byte[] PchFileName;

		internal int FileSize;

		internal int PreviewFileSize;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
		internal byte[] URL;

		internal uint VotesUp;

		internal uint VotesDown;

		internal float Score;

		internal uint NumChildren;

		internal string TitleUTF8()
		{
			return Encoding.UTF8.GetString(Title, 0, Array.IndexOf(Title, (byte)0));
		}

		internal string DescriptionUTF8()
		{
			return Encoding.UTF8.GetString(Description, 0, Array.IndexOf(Description, (byte)0));
		}

		internal string TagsUTF8()
		{
			return Encoding.UTF8.GetString(Tags, 0, Array.IndexOf(Tags, (byte)0));
		}

		internal string PchFileNameUTF8()
		{
			return Encoding.UTF8.GetString(PchFileName, 0, Array.IndexOf(PchFileName, (byte)0));
		}

		internal string URLUTF8()
		{
			return Encoding.UTF8.GetString(URL, 0, Array.IndexOf(URL, (byte)0));
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamItemDetails_t
	{
		internal InventoryItemId ItemId;

		internal InventoryDefId Definition;

		internal ushort Quantity;

		internal ushort Flags;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamTVRegion_t
	{
		internal uint UnMinX;

		internal uint UnMinY;

		internal uint UnMaxX;

		internal uint UnMaxY;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamNetworkingQuickConnectionStatus
	{
		internal ConnectionState State;

		internal int Ping;

		internal float ConnectionQualityLocal;

		internal float ConnectionQualityRemote;

		internal float OutPacketsPerSec;

		internal float OutBytesPerSec;

		internal float InPacketsPerSec;

		internal float InBytesPerSec;

		internal int SendRateBytesPerSecond;

		internal int CbPendingUnreliable;

		internal int CbPendingReliable;

		internal int CbSentUnackedReliable;

		internal long EcQueueTime;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16, ArraySubType = UnmanagedType.U4)]
		internal uint[] Reserved;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	internal struct SteamDatagramGameCoordinatorServerLogin
	{
		internal NetIdentity Dentity;

		internal SteamDatagramHostedAddress Outing;

		internal AppId AppID;

		internal uint Time;

		internal int CbAppData;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2048)]
		internal byte[] AppData;

		internal string AppDataUTF8()
		{
			return Encoding.UTF8.GetString(AppData, 0, Array.IndexOf(AppData, (byte)0));
		}
	}
	internal struct GID_t : IEquatable<GID_t>, IComparable<GID_t>
	{
		public ulong Value;

		public static implicit operator GID_t(ulong value)
		{
			GID_t result = default(GID_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(GID_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((GID_t)p);
		}

		public bool Equals(GID_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(GID_t a, GID_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(GID_t a, GID_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(GID_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct JobID_t : IEquatable<JobID_t>, IComparable<JobID_t>
	{
		public ulong Value;

		public static implicit operator JobID_t(ulong value)
		{
			JobID_t result = default(JobID_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(JobID_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((JobID_t)p);
		}

		public bool Equals(JobID_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(JobID_t a, JobID_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(JobID_t a, JobID_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(JobID_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct TxnID_t : IEquatable<TxnID_t>, IComparable<TxnID_t>
	{
		public ulong Value;

		public static implicit operator TxnID_t(ulong value)
		{
			TxnID_t result = default(TxnID_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(TxnID_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((TxnID_t)p);
		}

		public bool Equals(TxnID_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(TxnID_t a, TxnID_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(TxnID_t a, TxnID_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(TxnID_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct PackageId_t : IEquatable<PackageId_t>, IComparable<PackageId_t>
	{
		public uint Value;

		public static implicit operator PackageId_t(uint value)
		{
			PackageId_t result = default(PackageId_t);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(PackageId_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((PackageId_t)p);
		}

		public bool Equals(PackageId_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(PackageId_t a, PackageId_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(PackageId_t a, PackageId_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(PackageId_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct BundleId_t : IEquatable<BundleId_t>, IComparable<BundleId_t>
	{
		public uint Value;

		public static implicit operator BundleId_t(uint value)
		{
			BundleId_t result = default(BundleId_t);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(BundleId_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((BundleId_t)p);
		}

		public bool Equals(BundleId_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(BundleId_t a, BundleId_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(BundleId_t a, BundleId_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(BundleId_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct AssetClassId_t : IEquatable<AssetClassId_t>, IComparable<AssetClassId_t>
	{
		public ulong Value;

		public static implicit operator AssetClassId_t(ulong value)
		{
			AssetClassId_t result = default(AssetClassId_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(AssetClassId_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((AssetClassId_t)p);
		}

		public bool Equals(AssetClassId_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(AssetClassId_t a, AssetClassId_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(AssetClassId_t a, AssetClassId_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(AssetClassId_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct PhysicalItemId_t : IEquatable<PhysicalItemId_t>, IComparable<PhysicalItemId_t>
	{
		public uint Value;

		public static implicit operator PhysicalItemId_t(uint value)
		{
			PhysicalItemId_t result = default(PhysicalItemId_t);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(PhysicalItemId_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((PhysicalItemId_t)p);
		}

		public bool Equals(PhysicalItemId_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(PhysicalItemId_t a, PhysicalItemId_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(PhysicalItemId_t a, PhysicalItemId_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(PhysicalItemId_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct DepotId_t : IEquatable<DepotId_t>, IComparable<DepotId_t>
	{
		public uint Value;

		public static implicit operator DepotId_t(uint value)
		{
			DepotId_t result = default(DepotId_t);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(DepotId_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((DepotId_t)p);
		}

		public bool Equals(DepotId_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(DepotId_t a, DepotId_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(DepotId_t a, DepotId_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(DepotId_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct RTime32 : IEquatable<RTime32>, IComparable<RTime32>
	{
		public uint Value;

		public static implicit operator RTime32(uint value)
		{
			RTime32 result = default(RTime32);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(RTime32 value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((RTime32)p);
		}

		public bool Equals(RTime32 p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(RTime32 a, RTime32 b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(RTime32 a, RTime32 b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(RTime32 other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct CellID_t : IEquatable<CellID_t>, IComparable<CellID_t>
	{
		public uint Value;

		public static implicit operator CellID_t(uint value)
		{
			CellID_t result = default(CellID_t);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(CellID_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((CellID_t)p);
		}

		public bool Equals(CellID_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(CellID_t a, CellID_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(CellID_t a, CellID_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(CellID_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct SteamAPICall_t : IEquatable<SteamAPICall_t>, IComparable<SteamAPICall_t>
	{
		public ulong Value;

		public static implicit operator SteamAPICall_t(ulong value)
		{
			SteamAPICall_t result = default(SteamAPICall_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(SteamAPICall_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((SteamAPICall_t)p);
		}

		public bool Equals(SteamAPICall_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(SteamAPICall_t a, SteamAPICall_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(SteamAPICall_t a, SteamAPICall_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(SteamAPICall_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct AccountID_t : IEquatable<AccountID_t>, IComparable<AccountID_t>
	{
		public uint Value;

		public static implicit operator AccountID_t(uint value)
		{
			AccountID_t result = default(AccountID_t);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(AccountID_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((AccountID_t)p);
		}

		public bool Equals(AccountID_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(AccountID_t a, AccountID_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(AccountID_t a, AccountID_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(AccountID_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct PartnerId_t : IEquatable<PartnerId_t>, IComparable<PartnerId_t>
	{
		public uint Value;

		public static implicit operator PartnerId_t(uint value)
		{
			PartnerId_t result = default(PartnerId_t);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(PartnerId_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((PartnerId_t)p);
		}

		public bool Equals(PartnerId_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(PartnerId_t a, PartnerId_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(PartnerId_t a, PartnerId_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(PartnerId_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct ManifestId_t : IEquatable<ManifestId_t>, IComparable<ManifestId_t>
	{
		public ulong Value;

		public static implicit operator ManifestId_t(ulong value)
		{
			ManifestId_t result = default(ManifestId_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(ManifestId_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((ManifestId_t)p);
		}

		public bool Equals(ManifestId_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(ManifestId_t a, ManifestId_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(ManifestId_t a, ManifestId_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(ManifestId_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct SiteId_t : IEquatable<SiteId_t>, IComparable<SiteId_t>
	{
		public ulong Value;

		public static implicit operator SiteId_t(ulong value)
		{
			SiteId_t result = default(SiteId_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(SiteId_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((SiteId_t)p);
		}

		public bool Equals(SiteId_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(SiteId_t a, SiteId_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(SiteId_t a, SiteId_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(SiteId_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct PartyBeaconID_t : IEquatable<PartyBeaconID_t>, IComparable<PartyBeaconID_t>
	{
		public ulong Value;

		public static implicit operator PartyBeaconID_t(ulong value)
		{
			PartyBeaconID_t result = default(PartyBeaconID_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(PartyBeaconID_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((PartyBeaconID_t)p);
		}

		public bool Equals(PartyBeaconID_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(PartyBeaconID_t a, PartyBeaconID_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(PartyBeaconID_t a, PartyBeaconID_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(PartyBeaconID_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct HAuthTicket : IEquatable<HAuthTicket>, IComparable<HAuthTicket>
	{
		public uint Value;

		public static implicit operator HAuthTicket(uint value)
		{
			HAuthTicket result = default(HAuthTicket);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(HAuthTicket value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((HAuthTicket)p);
		}

		public bool Equals(HAuthTicket p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(HAuthTicket a, HAuthTicket b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(HAuthTicket a, HAuthTicket b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(HAuthTicket other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct BREAKPAD_HANDLE : IEquatable<BREAKPAD_HANDLE>, IComparable<BREAKPAD_HANDLE>
	{
		public IntPtr Value;

		public static implicit operator BREAKPAD_HANDLE(IntPtr value)
		{
			BREAKPAD_HANDLE result = default(BREAKPAD_HANDLE);
			result.Value = value;
			return result;
		}

		public static implicit operator IntPtr(BREAKPAD_HANDLE value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((BREAKPAD_HANDLE)p);
		}

		public bool Equals(BREAKPAD_HANDLE p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(BREAKPAD_HANDLE a, BREAKPAD_HANDLE b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(BREAKPAD_HANDLE a, BREAKPAD_HANDLE b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(BREAKPAD_HANDLE other)
		{
			return Value.ToInt64().CompareTo(other.Value.ToInt64());
		}
	}
	internal struct HSteamPipe : IEquatable<HSteamPipe>, IComparable<HSteamPipe>
	{
		public int Value;

		public static implicit operator HSteamPipe(int value)
		{
			HSteamPipe result = default(HSteamPipe);
			result.Value = value;
			return result;
		}

		public static implicit operator int(HSteamPipe value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((HSteamPipe)p);
		}

		public bool Equals(HSteamPipe p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(HSteamPipe a, HSteamPipe b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(HSteamPipe a, HSteamPipe b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(HSteamPipe other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct HSteamUser : IEquatable<HSteamUser>, IComparable<HSteamUser>
	{
		public int Value;

		public static implicit operator HSteamUser(int value)
		{
			HSteamUser result = default(HSteamUser);
			result.Value = value;
			return result;
		}

		public static implicit operator int(HSteamUser value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((HSteamUser)p);
		}

		public bool Equals(HSteamUser p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(HSteamUser a, HSteamUser b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(HSteamUser a, HSteamUser b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(HSteamUser other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct FriendsGroupID_t : IEquatable<FriendsGroupID_t>, IComparable<FriendsGroupID_t>
	{
		public short Value;

		public static implicit operator FriendsGroupID_t(short value)
		{
			FriendsGroupID_t result = default(FriendsGroupID_t);
			result.Value = value;
			return result;
		}

		public static implicit operator short(FriendsGroupID_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((FriendsGroupID_t)p);
		}

		public bool Equals(FriendsGroupID_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(FriendsGroupID_t a, FriendsGroupID_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(FriendsGroupID_t a, FriendsGroupID_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(FriendsGroupID_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct HServerListRequest : IEquatable<HServerListRequest>, IComparable<HServerListRequest>
	{
		public IntPtr Value;

		public static implicit operator HServerListRequest(IntPtr value)
		{
			HServerListRequest result = default(HServerListRequest);
			result.Value = value;
			return result;
		}

		public static implicit operator IntPtr(HServerListRequest value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((HServerListRequest)p);
		}

		public bool Equals(HServerListRequest p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(HServerListRequest a, HServerListRequest b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(HServerListRequest a, HServerListRequest b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(HServerListRequest other)
		{
			return Value.ToInt64().CompareTo(other.Value.ToInt64());
		}
	}
	internal struct HServerQuery : IEquatable<HServerQuery>, IComparable<HServerQuery>
	{
		public int Value;

		public static implicit operator HServerQuery(int value)
		{
			HServerQuery result = default(HServerQuery);
			result.Value = value;
			return result;
		}

		public static implicit operator int(HServerQuery value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((HServerQuery)p);
		}

		public bool Equals(HServerQuery p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(HServerQuery a, HServerQuery b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(HServerQuery a, HServerQuery b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(HServerQuery other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct UGCHandle_t : IEquatable<UGCHandle_t>, IComparable<UGCHandle_t>
	{
		public ulong Value;

		public static implicit operator UGCHandle_t(ulong value)
		{
			UGCHandle_t result = default(UGCHandle_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(UGCHandle_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((UGCHandle_t)p);
		}

		public bool Equals(UGCHandle_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(UGCHandle_t a, UGCHandle_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(UGCHandle_t a, UGCHandle_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(UGCHandle_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct PublishedFileUpdateHandle_t : IEquatable<PublishedFileUpdateHandle_t>, IComparable<PublishedFileUpdateHandle_t>
	{
		public ulong Value;

		public static implicit operator PublishedFileUpdateHandle_t(ulong value)
		{
			PublishedFileUpdateHandle_t result = default(PublishedFileUpdateHandle_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(PublishedFileUpdateHandle_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((PublishedFileUpdateHandle_t)p);
		}

		public bool Equals(PublishedFileUpdateHandle_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(PublishedFileUpdateHandle_t a, PublishedFileUpdateHandle_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(PublishedFileUpdateHandle_t a, PublishedFileUpdateHandle_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(PublishedFileUpdateHandle_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	public struct PublishedFileId : IEquatable<PublishedFileId>, IComparable<PublishedFileId>
	{
		public ulong Value;

		public static implicit operator PublishedFileId(ulong value)
		{
			PublishedFileId result = default(PublishedFileId);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(PublishedFileId value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((PublishedFileId)p);
		}

		public bool Equals(PublishedFileId p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(PublishedFileId a, PublishedFileId b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(PublishedFileId a, PublishedFileId b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(PublishedFileId other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct UGCFileWriteStreamHandle_t : IEquatable<UGCFileWriteStreamHandle_t>, IComparable<UGCFileWriteStreamHandle_t>
	{
		public ulong Value;

		public static implicit operator UGCFileWriteStreamHandle_t(ulong value)
		{
			UGCFileWriteStreamHandle_t result = default(UGCFileWriteStreamHandle_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(UGCFileWriteStreamHandle_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((UGCFileWriteStreamHandle_t)p);
		}

		public bool Equals(UGCFileWriteStreamHandle_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(UGCFileWriteStreamHandle_t a, UGCFileWriteStreamHandle_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(UGCFileWriteStreamHandle_t a, UGCFileWriteStreamHandle_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(UGCFileWriteStreamHandle_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct SteamLeaderboard_t : IEquatable<SteamLeaderboard_t>, IComparable<SteamLeaderboard_t>
	{
		public ulong Value;

		public static implicit operator SteamLeaderboard_t(ulong value)
		{
			SteamLeaderboard_t result = default(SteamLeaderboard_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(SteamLeaderboard_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((SteamLeaderboard_t)p);
		}

		public bool Equals(SteamLeaderboard_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(SteamLeaderboard_t a, SteamLeaderboard_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(SteamLeaderboard_t a, SteamLeaderboard_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(SteamLeaderboard_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct SteamLeaderboardEntries_t : IEquatable<SteamLeaderboardEntries_t>, IComparable<SteamLeaderboardEntries_t>
	{
		public ulong Value;

		public static implicit operator SteamLeaderboardEntries_t(ulong value)
		{
			SteamLeaderboardEntries_t result = default(SteamLeaderboardEntries_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(SteamLeaderboardEntries_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((SteamLeaderboardEntries_t)p);
		}

		public bool Equals(SteamLeaderboardEntries_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(SteamLeaderboardEntries_t a, SteamLeaderboardEntries_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(SteamLeaderboardEntries_t a, SteamLeaderboardEntries_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(SteamLeaderboardEntries_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct SNetSocket_t : IEquatable<SNetSocket_t>, IComparable<SNetSocket_t>
	{
		public uint Value;

		public static implicit operator SNetSocket_t(uint value)
		{
			SNetSocket_t result = default(SNetSocket_t);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(SNetSocket_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((SNetSocket_t)p);
		}

		public bool Equals(SNetSocket_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(SNetSocket_t a, SNetSocket_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(SNetSocket_t a, SNetSocket_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(SNetSocket_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct SNetListenSocket_t : IEquatable<SNetListenSocket_t>, IComparable<SNetListenSocket_t>
	{
		public uint Value;

		public static implicit operator SNetListenSocket_t(uint value)
		{
			SNetListenSocket_t result = default(SNetListenSocket_t);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(SNetListenSocket_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((SNetListenSocket_t)p);
		}

		public bool Equals(SNetListenSocket_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(SNetListenSocket_t a, SNetListenSocket_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(SNetListenSocket_t a, SNetListenSocket_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(SNetListenSocket_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct ScreenshotHandle : IEquatable<ScreenshotHandle>, IComparable<ScreenshotHandle>
	{
		public uint Value;

		public static implicit operator ScreenshotHandle(uint value)
		{
			ScreenshotHandle result = default(ScreenshotHandle);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(ScreenshotHandle value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((ScreenshotHandle)p);
		}

		public bool Equals(ScreenshotHandle p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(ScreenshotHandle a, ScreenshotHandle b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(ScreenshotHandle a, ScreenshotHandle b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(ScreenshotHandle other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct HTTPRequestHandle : IEquatable<HTTPRequestHandle>, IComparable<HTTPRequestHandle>
	{
		public uint Value;

		public static implicit operator HTTPRequestHandle(uint value)
		{
			HTTPRequestHandle result = default(HTTPRequestHandle);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(HTTPRequestHandle value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((HTTPRequestHandle)p);
		}

		public bool Equals(HTTPRequestHandle p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(HTTPRequestHandle a, HTTPRequestHandle b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(HTTPRequestHandle a, HTTPRequestHandle b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(HTTPRequestHandle other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct HTTPCookieContainerHandle : IEquatable<HTTPCookieContainerHandle>, IComparable<HTTPCookieContainerHandle>
	{
		public uint Value;

		public static implicit operator HTTPCookieContainerHandle(uint value)
		{
			HTTPCookieContainerHandle result = default(HTTPCookieContainerHandle);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(HTTPCookieContainerHandle value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((HTTPCookieContainerHandle)p);
		}

		public bool Equals(HTTPCookieContainerHandle p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(HTTPCookieContainerHandle a, HTTPCookieContainerHandle b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(HTTPCookieContainerHandle a, HTTPCookieContainerHandle b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(HTTPCookieContainerHandle other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct InputHandle_t : IEquatable<InputHandle_t>, IComparable<InputHandle_t>
	{
		public ulong Value;

		public static implicit operator InputHandle_t(ulong value)
		{
			InputHandle_t result = default(InputHandle_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(InputHandle_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((InputHandle_t)p);
		}

		public bool Equals(InputHandle_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(InputHandle_t a, InputHandle_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(InputHandle_t a, InputHandle_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(InputHandle_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct InputActionSetHandle_t : IEquatable<InputActionSetHandle_t>, IComparable<InputActionSetHandle_t>
	{
		public ulong Value;

		public static implicit operator InputActionSetHandle_t(ulong value)
		{
			InputActionSetHandle_t result = default(InputActionSetHandle_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(InputActionSetHandle_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((InputActionSetHandle_t)p);
		}

		public bool Equals(InputActionSetHandle_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(InputActionSetHandle_t a, InputActionSetHandle_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(InputActionSetHandle_t a, InputActionSetHandle_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(InputActionSetHandle_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct InputDigitalActionHandle_t : IEquatable<InputDigitalActionHandle_t>, IComparable<InputDigitalActionHandle_t>
	{
		public ulong Value;

		public static implicit operator InputDigitalActionHandle_t(ulong value)
		{
			InputDigitalActionHandle_t result = default(InputDigitalActionHandle_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(InputDigitalActionHandle_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((InputDigitalActionHandle_t)p);
		}

		public bool Equals(InputDigitalActionHandle_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(InputDigitalActionHandle_t a, InputDigitalActionHandle_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(InputDigitalActionHandle_t a, InputDigitalActionHandle_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(InputDigitalActionHandle_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct InputAnalogActionHandle_t : IEquatable<InputAnalogActionHandle_t>, IComparable<InputAnalogActionHandle_t>
	{
		public ulong Value;

		public static implicit operator InputAnalogActionHandle_t(ulong value)
		{
			InputAnalogActionHandle_t result = default(InputAnalogActionHandle_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(InputAnalogActionHandle_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((InputAnalogActionHandle_t)p);
		}

		public bool Equals(InputAnalogActionHandle_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(InputAnalogActionHandle_t a, InputAnalogActionHandle_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(InputAnalogActionHandle_t a, InputAnalogActionHandle_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(InputAnalogActionHandle_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct ControllerHandle_t : IEquatable<ControllerHandle_t>, IComparable<ControllerHandle_t>
	{
		public ulong Value;

		public static implicit operator ControllerHandle_t(ulong value)
		{
			ControllerHandle_t result = default(ControllerHandle_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(ControllerHandle_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((ControllerHandle_t)p);
		}

		public bool Equals(ControllerHandle_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(ControllerHandle_t a, ControllerHandle_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(ControllerHandle_t a, ControllerHandle_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(ControllerHandle_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct ControllerActionSetHandle_t : IEquatable<ControllerActionSetHandle_t>, IComparable<ControllerActionSetHandle_t>
	{
		public ulong Value;

		public static implicit operator ControllerActionSetHandle_t(ulong value)
		{
			ControllerActionSetHandle_t result = default(ControllerActionSetHandle_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(ControllerActionSetHandle_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((ControllerActionSetHandle_t)p);
		}

		public bool Equals(ControllerActionSetHandle_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(ControllerActionSetHandle_t a, ControllerActionSetHandle_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(ControllerActionSetHandle_t a, ControllerActionSetHandle_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(ControllerActionSetHandle_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct ControllerDigitalActionHandle_t : IEquatable<ControllerDigitalActionHandle_t>, IComparable<ControllerDigitalActionHandle_t>
	{
		public ulong Value;

		public static implicit operator ControllerDigitalActionHandle_t(ulong value)
		{
			ControllerDigitalActionHandle_t result = default(ControllerDigitalActionHandle_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(ControllerDigitalActionHandle_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((ControllerDigitalActionHandle_t)p);
		}

		public bool Equals(ControllerDigitalActionHandle_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(ControllerDigitalActionHandle_t a, ControllerDigitalActionHandle_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(ControllerDigitalActionHandle_t a, ControllerDigitalActionHandle_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(ControllerDigitalActionHandle_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct ControllerAnalogActionHandle_t : IEquatable<ControllerAnalogActionHandle_t>, IComparable<ControllerAnalogActionHandle_t>
	{
		public ulong Value;

		public static implicit operator ControllerAnalogActionHandle_t(ulong value)
		{
			ControllerAnalogActionHandle_t result = default(ControllerAnalogActionHandle_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(ControllerAnalogActionHandle_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((ControllerAnalogActionHandle_t)p);
		}

		public bool Equals(ControllerAnalogActionHandle_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(ControllerAnalogActionHandle_t a, ControllerAnalogActionHandle_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(ControllerAnalogActionHandle_t a, ControllerAnalogActionHandle_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(ControllerAnalogActionHandle_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct UGCQueryHandle_t : IEquatable<UGCQueryHandle_t>, IComparable<UGCQueryHandle_t>
	{
		public ulong Value;

		public static implicit operator UGCQueryHandle_t(ulong value)
		{
			UGCQueryHandle_t result = default(UGCQueryHandle_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(UGCQueryHandle_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((UGCQueryHandle_t)p);
		}

		public bool Equals(UGCQueryHandle_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(UGCQueryHandle_t a, UGCQueryHandle_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(UGCQueryHandle_t a, UGCQueryHandle_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(UGCQueryHandle_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct UGCUpdateHandle_t : IEquatable<UGCUpdateHandle_t>, IComparable<UGCUpdateHandle_t>
	{
		public ulong Value;

		public static implicit operator UGCUpdateHandle_t(ulong value)
		{
			UGCUpdateHandle_t result = default(UGCUpdateHandle_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(UGCUpdateHandle_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((UGCUpdateHandle_t)p);
		}

		public bool Equals(UGCUpdateHandle_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(UGCUpdateHandle_t a, UGCUpdateHandle_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(UGCUpdateHandle_t a, UGCUpdateHandle_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(UGCUpdateHandle_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct HHTMLBrowser : IEquatable<HHTMLBrowser>, IComparable<HHTMLBrowser>
	{
		public uint Value;

		public static implicit operator HHTMLBrowser(uint value)
		{
			HHTMLBrowser result = default(HHTMLBrowser);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(HHTMLBrowser value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((HHTMLBrowser)p);
		}

		public bool Equals(HHTMLBrowser p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(HHTMLBrowser a, HHTMLBrowser b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(HHTMLBrowser a, HHTMLBrowser b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(HHTMLBrowser other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	public struct InventoryItemId : IEquatable<InventoryItemId>, IComparable<InventoryItemId>
	{
		public ulong Value;

		public static implicit operator InventoryItemId(ulong value)
		{
			InventoryItemId result = default(InventoryItemId);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(InventoryItemId value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((InventoryItemId)p);
		}

		public bool Equals(InventoryItemId p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(InventoryItemId a, InventoryItemId b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(InventoryItemId a, InventoryItemId b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(InventoryItemId other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	public struct InventoryDefId : IEquatable<InventoryDefId>, IComparable<InventoryDefId>
	{
		public int Value;

		public static implicit operator InventoryDefId(int value)
		{
			InventoryDefId result = default(InventoryDefId);
			result.Value = value;
			return result;
		}

		public static implicit operator int(InventoryDefId value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((InventoryDefId)p);
		}

		public bool Equals(InventoryDefId p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(InventoryDefId a, InventoryDefId b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(InventoryDefId a, InventoryDefId b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(InventoryDefId other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct SteamInventoryResult_t : IEquatable<SteamInventoryResult_t>, IComparable<SteamInventoryResult_t>
	{
		public int Value;

		public static implicit operator SteamInventoryResult_t(int value)
		{
			SteamInventoryResult_t result = default(SteamInventoryResult_t);
			result.Value = value;
			return result;
		}

		public static implicit operator int(SteamInventoryResult_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((SteamInventoryResult_t)p);
		}

		public bool Equals(SteamInventoryResult_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(SteamInventoryResult_t a, SteamInventoryResult_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(SteamInventoryResult_t a, SteamInventoryResult_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(SteamInventoryResult_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct SteamInventoryUpdateHandle_t : IEquatable<SteamInventoryUpdateHandle_t>, IComparable<SteamInventoryUpdateHandle_t>
	{
		public ulong Value;

		public static implicit operator SteamInventoryUpdateHandle_t(ulong value)
		{
			SteamInventoryUpdateHandle_t result = default(SteamInventoryUpdateHandle_t);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(SteamInventoryUpdateHandle_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((SteamInventoryUpdateHandle_t)p);
		}

		public bool Equals(SteamInventoryUpdateHandle_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(SteamInventoryUpdateHandle_t a, SteamInventoryUpdateHandle_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(SteamInventoryUpdateHandle_t a, SteamInventoryUpdateHandle_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(SteamInventoryUpdateHandle_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct RemotePlaySessionID_t : IEquatable<RemotePlaySessionID_t>, IComparable<RemotePlaySessionID_t>
	{
		public uint Value;

		public static implicit operator RemotePlaySessionID_t(uint value)
		{
			RemotePlaySessionID_t result = default(RemotePlaySessionID_t);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(RemotePlaySessionID_t value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((RemotePlaySessionID_t)p);
		}

		public bool Equals(RemotePlaySessionID_t p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(RemotePlaySessionID_t a, RemotePlaySessionID_t b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(RemotePlaySessionID_t a, RemotePlaySessionID_t b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(RemotePlaySessionID_t other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct HSteamNetPollGroup : IEquatable<HSteamNetPollGroup>, IComparable<HSteamNetPollGroup>
	{
		public uint Value;

		public static implicit operator HSteamNetPollGroup(uint value)
		{
			HSteamNetPollGroup result = default(HSteamNetPollGroup);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(HSteamNetPollGroup value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((HSteamNetPollGroup)p);
		}

		public bool Equals(HSteamNetPollGroup p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(HSteamNetPollGroup a, HSteamNetPollGroup b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(HSteamNetPollGroup a, HSteamNetPollGroup b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(HSteamNetPollGroup other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	internal struct SteamNetworkingPOPID : IEquatable<SteamNetworkingPOPID>, IComparable<SteamNetworkingPOPID>
	{
		public uint Value;

		public static implicit operator SteamNetworkingPOPID(uint value)
		{
			SteamNetworkingPOPID result = default(SteamNetworkingPOPID);
			result.Value = value;
			return result;
		}

		public static implicit operator uint(SteamNetworkingPOPID value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}

		public override int GetHashCode()
		{
			return Value.GetHashCode();
		}

		public override bool Equals(object p)
		{
			return Equals((SteamNetworkingPOPID)p);
		}

		public bool Equals(SteamNetworkingPOPID p)
		{
			return p.Value == Value;
		}

		public static bool operator ==(SteamNetworkingPOPID a, SteamNetworkingPOPID b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(SteamNetworkingPOPID a, SteamNetworkingPOPID b)
		{
			return !a.Equals(b);
		}

		public int CompareTo(SteamNetworkingPOPID other)
		{
			return Value.CompareTo(other.Value);
		}
	}
	public struct Connection
	{
		public uint Id { get; set; }

		public long UserData
		{
			get
			{
				return SteamNetworkingSockets.Internal.GetConnectionUserData(this);
			}
			set
			{
				SteamNetworkingSockets.Internal.SetConnectionUserData(this, value);
			}
		}

		public string ConnectionName
		{
			get
			{
				if (!SteamNetworkingSockets.Internal.GetConnectionName(this, out var pszName))
				{
					return "ERROR";
				}
				return pszName;
			}
			set
			{
				SteamNetworkingSockets.Internal.SetConnectionName(this, value);
			}
		}

		public override string ToString()
		{
			return Id.ToString();
		}

		public static implicit operator Connection(uint value)
		{
			Connection result = default(Connection);
			result.Id = value;
			return result;
		}

		public static implicit operator uint(Connection value)
		{
			return value.Id;
		}

		public Result Accept()
		{
			return SteamNetworkingSockets.Internal.AcceptConnection(this);
		}

		public bool Close(bool linger = false, int reasonCode = 0, string debugString = "Closing Connection")
		{
			return SteamNetworkingSockets.Internal.CloseConnection(this, reasonCode, debugString, linger);
		}

		public Result SendMessage(IntPtr ptr, int size, SendType sendType = SendType.Reliable)
		{
			long pOutMessageNumber = 0L;
			return SteamNetworkingSockets.Internal.SendMessageToConnection(this, ptr, (uint)size, (int)sendType, ref pOutMessageNumber);
		}

		public unsafe Result SendMessage(byte[] data, SendType sendType = SendType.Reliable)
		{
			fixed (byte* ptr = data)
			{
				return SendMessage((IntPtr)ptr, data.Length, sendType);
			}
		}

		public unsafe Result SendMessage(byte[] data, int offset, int length, SendType sendType = SendType.Reliable)
		{
			fixed (byte* ptr = data)
			{
				return SendMessage((IntPtr)ptr + offset, length, sendType);
			}
		}

		public Result SendMessage(string str, SendType sendType = SendType.Reliable)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(str);
			return SendMessage(bytes, sendType);
		}

		public Result Flush()
		{
			return SteamNetworkingSockets.Internal.FlushMessagesOnConnection(this);
		}

		public string DetailedStatus()
		{
			if (SteamNetworkingSockets.Internal.GetDetailedConnectionStatus(this, out var pszBuf) != 0)
			{
				return null;
			}
			return pszBuf;
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 696)]
	public struct ConnectionInfo
	{
		internal NetIdentity identity;

		internal long userData;

		internal Socket listenSocket;

		internal NetAddress address;

		internal ushort pad;

		internal SteamNetworkingPOPID popRemote;

		internal SteamNetworkingPOPID popRelay;

		internal ConnectionState state;

		internal int endReason;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
		internal string endDebug;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
		internal string connectionDescription;

		public ConnectionState State => state;

		public NetAddress Address => address;

		public NetIdentity Identity => address;

		public NetConnectionEnd EndReason => (NetConnectionEnd)endReason;
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	internal delegate void NetDebugFunc([In] NetDebugOutput nType, [In] IntPtr pszMsg);
	internal struct NetErrorMessage
	{
		public unsafe fixed char Value[1024];
	}
	[StructLayout(LayoutKind.Explicit, Pack = 8)]
	internal struct NetKeyValue
	{
		[FieldOffset(0)]
		internal NetConfig Value;

		[FieldOffset(4)]
		internal NetConfigType DataType;

		[FieldOffset(8)]
		internal long Int64Value;

		[FieldOffset(8)]
		internal int Int32Value;

		[FieldOffset(8)]
		internal float FloatValue;

		[FieldOffset(8)]
		internal IntPtr PointerValue;
	}
	[StructLayout(LayoutKind.Explicit, Size = 512)]
	public struct NetPingLocation
	{
		public static NetPingLocation? TryParseFromString(string str)
		{
			NetPingLocation result = default(NetPingLocation);
			if (!SteamNetworkingUtils.Internal.ParsePingLocationString(str, ref result))
			{
				return null;
			}
			return result;
		}

		public override string ToString()
		{
			SteamNetworkingUtils.Internal.ConvertPingLocationToString(ref this, out var pszBuf);
			return pszBuf;
		}

		public int EstimatePingTo(NetPingLocation target)
		{
			return SteamNetworkingUtils.Internal.EstimatePingTimeBetweenTwoLocations(ref this, ref target);
		}
	}
	public struct Socket
	{
		internal uint Id;

		public SocketManager Manager
		{
			get
			{
				return SteamNetworkingSockets.GetSocketManager(Id);
			}
			set
			{
				SteamNetworkingSockets.SetSocketManager(Id, value);
			}
		}

		public override string ToString()
		{
			return Id.ToString();
		}

		public static implicit operator Socket(uint value)
		{
			Socket result = default(Socket);
			result.Id = value;
			return result;
		}

		public static implicit operator uint(Socket value)
		{
			return value.Id;
		}

		public bool Close()
		{
			return SteamNetworkingSockets.Internal.CloseListenSocket(Id);
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct SteamDatagramRelayAuthTicket
	{
	}
	public struct Achievement
	{
		internal string Value;

		public bool State
		{
			get
			{
				bool pbAchieved = false;
				SteamUserStats.Internal.GetAchievement(Value, ref pbAchieved);
				return pbAchieved;
			}
		}

		public string Identifier => Value;

		public string Name => SteamUserStats.Internal.GetAchievementDisplayAttribute(Value, "name");

		public string Description => SteamUserStats.Internal.GetAchievementDisplayAttribute(Value, "desc");

		public DateTime? UnlockTime
		{
			get
			{
				bool pbAchieved = false;
				uint punUnlockTime = 0u;
				if (!SteamUserStats.Internal.GetAchievementAndUnlockTime(Value, ref pbAchieved, ref punUnlockTime) || !pbAchieved)
				{
					return null;
				}
				return Epoch.ToDateTime(punUnlockTime);
			}
		}

		public float GlobalUnlocked
		{
			get
			{
				float pflPercent = 0f;
				if (!SteamUserStats.Internal.GetAchievementAchievedPercent(Value, ref pflPercent))
				{
					return -1f;
				}
				return pflPercent / 100f;
			}
		}

		public Achievement(string name)
		{
			Value = name;
		}

		public override string ToString()
		{
			return Value;
		}

		public Image? GetIcon()
		{
			return SteamUtils.GetImage(SteamUserStats.Internal.GetAchievementIcon(Value));
		}

		public async Task<Image?> GetIconAsync(int timeout = 5000)
		{
			int i = SteamUserStats.Internal.GetAchievementIcon(Value);
			if (i != 0)
			{
				return SteamUtils.GetImage(i);
			}
			string ident = Identifier;
			bool gotCallback = false;
			try
			{
				SteamUserStats.OnAchievementIconFetched += f;
				int waited = 0;
				while (!gotCallback)
				{
					await Task.Delay(10);
					waited += 10;
					if (waited > timeout)
					{
						return null;
					}
				}
				if (i == 0)
				{
					return null;
				}
				return SteamUtils.GetImage(i);
			}
			finally
			{
				SteamUserStats.OnAchievementIconFetched -= f;
			}
			void f(string x, int icon)
			{
				if (!(x != ident))
				{
					i = icon;
					gotCallback = true;
				}
			}
		}

		public bool Trigger(bool apply = true)
		{
			bool flag = SteamUserStats.Internal.SetAchievement(Value);
			if (apply && flag)
			{
				SteamUserStats.Internal.StoreStats();
			}
			return flag;
		}

		public bool Clear()
		{
			return SteamUserStats.Internal.ClearAchievement(Value);
		}
	}
	public struct DepotId
	{
		public uint Value;

		public static implicit operator DepotId(uint value)
		{
			DepotId result = default(DepotId);
			result.Value = value;
			return result;
		}

		public static implicit operator DepotId(int value)
		{
			DepotId result = default(DepotId);
			result.Value = (uint)value;
			return result;
		}

		public static implicit operator uint(DepotId value)
		{
			return value.Value;
		}

		public override string ToString()
		{
			return Value.ToString();
		}
	}
	public struct DlcInformation
	{
		public AppId AppId { get; internal set; }

		public string Name { get; internal set; }

		public bool Available { get; internal set; }
	}
	public struct DownloadProgress
	{
		public bool Active;

		public ulong BytesDownloaded;

		public ulong BytesTotal;
	}
	public struct DurationControl
	{
		internal DurationControl_t _inner;

		public AppId Appid => _inner.Appid;

		public bool Applicable => _inner.Applicable;

		internal TimeSpan PlaytimeInLastFiveHours => TimeSpan.FromSeconds(_inner.CsecsLast5h);

		internal TimeSpan PlaytimeToday => TimeSpan.FromSeconds(_inner.CsecsLast5h);

		internal DurationControlProgress Progress => _inner.Progress;
	}
	public struct FileDetails
	{
		public ulong SizeInBytes;

		public string Sha1;

		public uint Flags;
	}
	public struct GameId
	{
		public ulong Value;

		public static implicit operator GameId(ulong value)
		{
			GameId result = default(GameId);
			result.Value = value;
			return result;
		}

		public static implicit operator ulong(GameId value)
		{
			return value.Value;
		}
	}
	public struct Image
	{
		public uint Width;

		public uint Height;

		public byte[] Data;

		public Color GetPixel(int x, int y)
		{
			if (x < 0 || x >= Width)
			{
				throw new Exception("x out of bounds");
			}
			if (y < 0 || y >= Height)
			{
				throw new Exception("y out of bounds");
			}
			Color result = default(Color);
			long num = (y * Width + x) * 4;
			result.r = Data[num];
			result.g = Data[num + 1];
			result.b = Data[num + 2];
			result.a = Data[num + 3];
			return result;
		}

		public override string ToString()
		{
			return $"{Width}x{Height} ({Data.Length}bytes)";
		}
	}
	public struct Color
	{
		public byte r;

		public byte g;

		public byte b;

		public byte a;
	}
	public struct InventoryPurchaseResult
	{
		public Result Result;

		public ulong OrderID;

		public ulong TransID;
	}
	public struct Leaderboard
	{
		internal SteamLeaderboard_t Id;

		private static int[] detailsBuffer = new int[64];

		private static int[] noDetails = Array.Empty<int>();

		public string Name => SteamUserStats.Internal.GetLeaderboardName(Id);

		public LeaderboardSort Sort => SteamUserStats.Internal.GetLeaderboardSortMethod(Id);

		public LeaderboardDisplay Display => SteamUserStats.Internal.GetLeaderboardDisplayType(Id);

		public int EntryCount => SteamUserStats.Internal.GetLeaderboardEntryCount(Id);

		public async Task<LeaderboardUpdate?> ReplaceScore(int score, int[] details = null)
		{
			if (details == null)
			{
				details = noDetails;
			}
			LeaderboardScoreUploaded_t? leaderboardScoreUploaded_t = await SteamUserStats.Internal.UploadLeaderboardScore(Id, LeaderboardUploadScoreMethod.ForceUpdate, score, details, details.Length);
			if (!leaderboardScoreUploaded_t.HasValue)
			{
				return null;
			}
			return LeaderboardUpdate.From(leaderboardScoreUploaded_t.Value);
		}

		public async Task<LeaderboardUpdate?> SubmitScoreAsync(int score, int[] details = null)
		{
			if (details == null)
			{
				details = noDetails;
			}
			LeaderboardScoreUploaded_t? leaderboardScoreUploaded_t = await SteamUserStats.Internal.UploadLeaderboardScore(Id, LeaderboardUploadScoreMethod.KeepBest, score, details, details.Length);
			if (!leaderboardScoreUploaded_t.HasValue)
			{
				return null;
			}
			return LeaderboardUpdate.From(leaderboardScoreUploaded_t.Value);
		}

		public async Task<Result> AttachUgc(Ugc file)
		{
			LeaderboardUGCSet_t? leaderboardUGCSet_t = await SteamUserStats.Internal.AttachLeaderboardUGC(Id, file.Handle);
			if (!leaderboardUGCSet_t.HasValue)
			{
				return Result.Fail;
			}
			return leaderboardUGCSet_t.Value.Result;
		}

		public async Task<LeaderboardEntry[]> GetScoresAsync(int count, int offset = 1)
		{
			if (offset <= 0)
			{
				throw new ArgumentException("Should be 1+", "offset");
			}
			LeaderboardScoresDownloaded_t? leaderboardScoresDownloaded_t = await SteamUserStats.Internal.DownloadLeaderboardEntries(Id, LeaderboardDataRequest.Global, offset, offset + count);
			if (!leaderboardScoresDownloaded_t.HasValue)
			{
				return null;
			}
			return await LeaderboardResultToEntries(leaderboardScoresDownloaded_t.Value);
		}

		public async Task<LeaderboardEntry[]> GetScoresAroundUserAsync(int start = -10, int end = 10)
		{
			LeaderboardScoresDownloaded_t? leaderboardScoresDownloaded_t = await SteamUserStats.Internal.DownloadLeaderboardEntries(Id, LeaderboardDataRequest.GlobalAroundUser, start, end);
			if (!leaderboardScoresDownloaded_t.HasValue)
			{
				return null;
			}
			return await LeaderboardResultToEntries(leaderboardScoresDownloaded_t.Value);
		}

		public async Task<LeaderboardEntry[]> GetScoresFromFriendsAsync()
		{
			LeaderboardScoresDownloaded_t? leaderboardScoresDownloaded_t = await SteamUserStats.Internal.DownloadLeaderboardEntries(Id, LeaderboardDataRequest.Friends, 0, 0);
			if (!leaderboardScoresDownloaded_t.HasValue)
			{
				return null;
			}
			return await LeaderboardResultToEntries(leaderboardScoresDownloaded_t.Value);
		}

		internal async Task<LeaderboardEntry[]> LeaderboardResultToEntries(LeaderboardScoresDownloaded_t r)
		{
			if (r.CEntryCount <= 0)
			{
				return null;
			}
			LeaderboardEntry[] output = new LeaderboardEntry[r.CEntryCount];
			LeaderboardEntry_t pLeaderboardEntry = default(LeaderboardEntry_t);
			for (int i = 0; i < output.Length; i++)
			{
				if (SteamUserStats.Internal.GetDownloadedLeaderboardEntry(r.SteamLeaderboardEntries, i, ref pLeaderboardEntry, detailsBuffer, detailsBuffer.Length))
				{
					output[i] = LeaderboardEntry.From(pLeaderboardEntry, detailsBuffer);
				}
			}
			await WaitForUserNames(output);
			return output;
		}

		internal static async Task WaitForUserNames(LeaderboardEntry[] entries)
		{
			bool gotAll = false;
			while (!gotAll)
			{
				gotAll = true;
				for (int i = 0; i < entries.Length; i++)
				{
					LeaderboardEntry leaderboardEntry = entries[i];
					if ((ulong)leaderboardEntry.User.Id != 0L && SteamFriends.Internal.RequestUserInformation(leaderboardEntry.User.Id, bRequireNameOnly: true))
					{
						gotAll = false;
					}
				}
				await Task.Delay(1);
			}
		}
	}
	public struct LeaderboardEntry
	{
		public Friend User;

		public int GlobalRank;

		public int Score;

		public int[] Details;

		internal static LeaderboardEntry From(LeaderboardEntry_t e, int[] detailsBuffer)
		{
			LeaderboardEntry leaderboardEntry = default(LeaderboardEntry);
			leaderboardEntry.User = new Friend(e.SteamIDUser);
			leaderboardEntry.GlobalRank = e.GlobalRank;
			leaderboardEntry.Score = e.Score;
			leaderboardEntry.Details = null;
			LeaderboardEntry result = leaderboardEntry;
			if (e.CDetails > 0)
			{
				result.Details = detailsBuffer.Take(e.CDetails).ToArray();
			}
			return result;
		}
	}
	public struct LeaderboardUpdate
	{
		public int Score;

		public bool Changed;

		public int NewGlobalRank;

		public int OldGlobalRank;

		public int RankChange => NewGlobalRank - OldGlobalRank;

		internal static LeaderboardUpdate From(LeaderboardScoreUploaded_t e)
		{
			LeaderboardUpdate result = default(LeaderboardUpdate);
			result.Score = e.Score;
			result.Changed = e.ScoreChanged == 1;
			result.NewGlobalRank = e.GlobalRankNew;
			result.OldGlobalRank = e.GlobalRankPrevious;
			return result;
		}
	}
	public struct Lobby
	{
		[CompilerGenerated]
		private sealed class <get_Data>d__16 : IEnumerable<KeyValuePair<string, string>>, IEnumerable, IEnumerator<KeyValuePair<string, string>>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private KeyValuePair<string, string> <>2__current;

			private int <>l__initialThreadId;

			public Lobby <>4__this;

			public Lobby <>3__<>4__this;

			private int <cnt>5__2;

			private int <i>5__3;

			KeyValuePair<string, string> IEnumerator<KeyValuePair<string, string>>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <get_Data>d__16(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0079;
				}
				<>1__state = -1;
				<cnt>5__2 = SteamMatchmaking.Internal.GetLobbyDataCount(<>4__this.Id);
				<i>5__3 = 0;
				goto IL_0089;
				IL_0079:
				<i>5__3++;
				goto IL_0089;
				IL_0089:
				if (<i>5__3 < <cnt>5__2)
				{
					if (SteamMatchmaking.Internal.GetLobbyDataByIndex(<>4__this.Id, <i>5__3, out var pchKey, out var pchValue))
					{
						<>2__current = new KeyValuePair<string, string>(pchKey, pchValue);
						<>1__state = 1;
						return true;
					}
					goto IL_0079;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<KeyValuePair<string, string>> IEnumerable<KeyValuePair<string, string>>.GetEnumerator()
			{
				<get_Data>d__16 <get_Data>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<get_Data>d__ = this;
				}
				else
				{
					<get_Data>d__ = new <get_Data>d__16(0);
				}
				<get_Data>d__.<>4__this = <>3__<>4__this;
				return <get_Data>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<KeyValuePair<string, string>>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <get_Members>d__11 : IEnumerable<Friend>, IEnumerable, IEnumerator<Friend>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private Friend <>2__current;

			private int <>l__initialThreadId;

			public Lobby <>4__this;

			public Lobby <>3__<>4__this;

			private int <i>5__2;

			Friend IEnumerator<Friend>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <get_Members>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < <>4__this.MemberCount)
				{
					<>2__current = new Friend(SteamMatchmaking.Internal.GetLobbyMemberByIndex(<>4__this.Id, <i>5__2));
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<Friend> IEnumerable<Friend>.GetEnumerator()
			{
				<get_Members>d__11 <get_Members>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<get_Members>d__ = this;
				}
				else
				{
					<get_Members>d__ = new <get_Members>d__11(0);
				}
				<get_Members>d__.<>4__this = <>3__<>4__this;
				return <get_Members>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Friend>)this).GetEnumerator();
			}
		}

		public SteamId Id { get; internal set; }

		public int MemberCount => SteamMatchmaking.Internal.GetNumLobbyMembers(Id);

		public IEnumerable<Friend> Members
		{
			[IteratorStateMachine(typeof(<get_Members>d__11))]
			get
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <get_Members>d__11(-2)
				{
					<>3__<>4__this = this
				};
			}
		}

		public IEnumerable<KeyValuePair<string, string>> Data
		{
			[IteratorStateMachine(typeof(<get_Data>d__16))]
			get
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <get_Data>d__16(-2)
				{
					<>3__<>4__this = this
				};
			}
		}

		public int MaxMembers
		{
			get
			{
				return SteamMatchmaking.Internal.GetLobbyMemberLimit(Id);
			}
			set
			{
				SteamMatchmaking.Internal.SetLobbyMemberLimit(Id, value);
			}
		}

		public Friend Owner
		{
			get
			{
				return new Friend(SteamMatchmaking.Internal.GetLobbyOwner(Id));
			}
			set
			{
				SteamMatchmaking.Internal.SetLobbyOwner(Id, value.Id);
			}
		}

		public Lobby(SteamId id)
		{
			Id = id;
		}

		public async Task<RoomEnter> Join()
		{
			LobbyEnter_t? lobbyEnter_t = await SteamMatchmaking.Internal.JoinLobby(Id);
			if (!lobbyEnter_t.HasValue)
			{
				return RoomEnter.Error;
			}
			return (RoomEnter)lobbyEnter_t.Value.EChatRoomEnterResponse;
		}

		public void Leave()
		{
			SteamMatchmaking.Internal.LeaveLobby(Id);
		}

		public bool InviteFriend(SteamId steamid)
		{
			return SteamMatchmaking.Internal.InviteUserToLobby(Id, steamid);
		}

		public string GetData(string key)
		{
			return SteamMatchmaking.Internal.GetLobbyData(Id, key);
		}

		public bool SetData(string key, string value)
		{
			if (key.Length > 255)
			{
				throw new ArgumentException("Key should be < 255 chars", "key");
			}
			if (value.Length > 8192)
			{
				throw new ArgumentException("Value should be < 8192 chars", "key");
			}
			return SteamMatchmaking.Internal.SetLobbyData(Id, key, value);
		}

		public bool DeleteData(string key)
		{
			return SteamMatchmaking.Internal.DeleteLobbyData(Id, key);
		}

		public string GetMemberData(Friend member, string key)
		{
			return SteamMatchmaking.Internal.GetLobbyMemberData(Id, member.Id, key);
		}

		public void SetMemberData(string key, string value)
		{
			SteamMatchmaking.Internal.SetLobbyMemberData(Id, key, value);
		}

		public bool SendChatString(string message)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(message);
			return SendChatBytes(bytes);
		}

		internal unsafe bool SendChatBytes(byte[] data)
		{
			fixed (byte* ptr = data)
			{
				return SteamMatchmaking.Internal.SendLobbyChatMsg(Id, (IntPtr)ptr, data.Length);
			}
		}

		public bool Refresh()
		{
			return SteamMatchmaking.Internal.RequestLobbyData(Id);
		}

		public bool SetPublic()
		{
			return SteamMatchmaking.Internal.SetLobbyType(Id, LobbyType.Public);
		}

		public bool SetPrivate()
		{
			return SteamMatchmaking.Internal.SetLobbyType(Id, LobbyType.Private);
		}

		public bool SetInvisible()
		{
			return SteamMatchmaking.Internal.SetLobbyType(Id, LobbyType.Invisible);
		}

		public bool SetFriendsOnly()
		{
			return SteamMatchmaking.Internal.SetLobbyType(Id, LobbyType.FriendsOnly);
		}

		public bool SetJoinable(bool b)
		{
			return SteamMatchmaking.Internal.SetLobbyJoinable(Id, b);
		}

		public void SetGameServer(SteamId steamServer)
		{
			if (!steamServer.IsValid)
			{
				throw new ArgumentException("SteamId for server is invalid");
			}
			SteamMatchmaking.Internal.SetLobbyGameServer(Id, 0u, 0, steamServer);
		}

		public void SetGameServer(string ip, ushort port)
		{
			if (!IPAddress.TryParse(ip, out IPAddress address))
			{
				throw new ArgumentException("IP address for server is invalid");
			}
			SteamMatchmaking.Internal.SetLobbyGameServer(Id, address.IpToInt32(), port, default(SteamId));
		}

		public bool GetGameServer(ref uint ip, ref ushort port, ref SteamId serverId)
		{
			return SteamMatchmaking.Internal.GetLobbyGameServer(Id, ref ip, ref port, ref serverId);
		}

		public bool IsOwnedBy(SteamId k)
		{
			return (ulong)Owner.Id == (ulong)k;
		}
	}
	public struct LobbyQuery
	{
		internal LobbyDistanceFilter? distance;

		internal Dictionary<string, string> stringFilters;

		internal List<NumericalFilter> numericalFilters;

		internal Dictionary<string, int> nearValFilters;

		internal int? slotsAvailable;

		internal int? maxResults;

		public LobbyQuery FilterDistanceClose()
		{
			distance = LobbyDistanceFilter.Close;
			return this;
		}

		public LobbyQuery FilterDistanceFar()
		{
			distance = LobbyDistanceFilter.Far;
			return this;
		}

		public LobbyQuery FilterDistanceWorldwide()
		{
			distance = LobbyDistanceFilter.Worldwide;
			return this;
		}

		public LobbyQuery WithKeyValue(string key, string value)
		{
			if (string.IsNullOrEmpty(key))
			{
				throw new ArgumentException("Key string provided for LobbyQuery filter is null or empty", "key");
			}
			if (key.Length > SteamMatchmaking.MaxLobbyKeyLength)
			{
				throw new ArgumentException($"Key length is longer than {SteamMatchmaking.MaxLobbyKeyLength}", "key");
			}
			if (stringFilters == null)
			{
				stringFilters = new Dictionary<string, string>();
			}
			stringFilters.Add(key, value);
			return this;
		}

		public LobbyQuery WithLower(string key, int value)
		{
			AddNumericalFilter(key, value, LobbyComparison.LessThan);
			return this;
		}

		public LobbyQuery WithHigher(string key, int value)
		{
			AddNumericalFilter(key, value, LobbyComparison.GreaterThan);
			return this;
		}

		public LobbyQuery WithEqual(string key, int value)
		{
			AddNumericalFilter(key, value, LobbyComparison.Equal);
			return this;
		}

		public LobbyQuery WithNotEqual(string key, int value)
		{
			AddNumericalFilter(key, value, LobbyComparison.NotEqual);
			return this;
		}

		internal void AddNumericalFilter(string key, int value, LobbyComparison compare)
		{
			if (string.IsNullOrEmpty(key))
			{
				throw new ArgumentException("Key string provided for LobbyQuery filter is null or empty", "key");
			}
			if (key.Length > SteamMatchmaking.MaxLobbyKeyLength)
			{
				throw new ArgumentException($"Key length is longer than {SteamMatchmaking.MaxLobbyKeyLength}", "key");
			}
			if (numericalFilters == null)
			{
				numericalFilters = new List<NumericalFilter>();
			}
			numericalFilters.Add(new NumericalFilter(key, value, compare));
		}

		public LobbyQuery OrderByNear(string key, int value)
		{
			if (string.IsNullOrEmpty(key))
			{
				throw new ArgumentException("Key string provided for LobbyQuery filter is null or empty", "key");
			}
			if (key.Length > SteamMatchmaking.MaxLobbyKeyLength)
			{
				throw new ArgumentException($"Key length is longer than {SteamMatchmaking.MaxLobbyKeyLength}", "key");
			}
			if (nearValFilters == null)
			{
				nearValFilters = new Dictionary<string, int>();
			}
			nearValFilters.Add(key, value);
			return this;
		}

		public LobbyQuery WithSlotsAvailable(int minSlots)
		{
			slotsAvailable = minSlots;
			return this;
		}

		public LobbyQuery WithMaxResults(int max)
		{
			maxResults = max;
			return this;
		}

		private void ApplyFilters()
		{
			if (distance.HasValue)
			{
				SteamMatchmaking.Internal.AddRequestLobbyListDistanceFilter(distance.Value);
			}
			if (slotsAvailable.HasValue)
			{
				SteamMatchmaking.Internal.AddRequestLobbyListFilterSlotsAvailable(slotsAvailable.Value);
			}
			if (maxResults.HasValue)
			{
				SteamMatchmaking.Internal.AddRequestLobbyListResultCountFilter(maxResults.Value);
			}
			if (stringFilters != null)
			{
				foreach (KeyValuePair<string, string> stringFilter in stringFilters)
				{
					SteamMatchmaking.Internal.AddRequestLobbyListStringFilter(stringFilter.Key, stringFilter.Value, LobbyComparison.Equal);
				}
			}
			if (numericalFilters != null)
			{
				foreach (NumericalFilter numericalFilter in numericalFilters)
				{
					SteamMatchmaking.Internal.AddRequestLobbyListNumericalFilter(numericalFilter.Key, numericalFilter.Value, numericalFilter.Comparer);
				}
			}
			if (nearValFilters == null)
			{
				return;
			}
			foreach (KeyValuePair<string, int> nearValFilter in nearValFilters)
			{
				SteamMatchmaking.Internal.AddRequestLobbyListNearValueFilter(nearValFilter.Key, nearValFilter.Value);
			}
		}

		public async Task<Lobby[]> RequestAsync()
		{
			ApplyFilters();
			LobbyMatchList_t? lobbyMatchList_t = await SteamMatchmaking.Internal.RequestLobbyList();
			if (!lobbyMatchList_t.HasValue || lobbyMatchList_t.Value.LobbiesMatching == 0)
			{
				return null;
			}
			Lobby[] array = new Lobby[lobbyMatchList_t.Value.LobbiesMatching];
			for (int i = 0; i < lobbyMatchList_t.Value.LobbiesMatching; i++)
			{
				array[i] = new Lobby
				{
					Id = SteamMatchmaking.Internal.GetLobbyByIndex(i)
				};
			}
			return array;
		}
	}
	internal struct NumericalFilter
	{
		public string Key { get; internal set; }

		public int Value { get; internal set; }

		public LobbyComparison Comparer { get; internal set; }

		internal NumericalFilter(string k, int v, LobbyComparison c)
		{
			Key = k;
			Value = v;
			Comparer = c;
		}
	}
	public struct OutgoingPacket
	{
		public uint Address { get; internal set; }

		public ushort Port { get; internal set; }

		public byte[] Data { get; internal set; }

		public int Size { get; internal set; }
	}
	public struct P2Packet
	{
		public SteamId SteamId;

		public byte[] Data;
	}
	public struct RemotePlaySession
	{
		public uint Id { get; set; }

		public bool IsValid => Id != 0;

		public SteamId SteamId => SteamRemotePlay.Internal.GetSessionSteamID(Id);

		public string ClientName => SteamRemotePlay.Internal.GetSessionClientName(Id);

		public SteamDeviceFormFactor FormFactor => SteamRemotePlay.Internal.GetSessionClientFormFactor(Id);

		public override string ToString()
		{
			return Id.ToString();
		}

		public static implicit operator RemotePlaySession(uint value)
		{
			RemotePlaySession result = default(RemotePlaySession);
			result.Id = value;
			return result;
		}

		public static implicit operator uint(RemotePlaySession value)
		{
			return value.Id;
		}
	}
	public struct Screenshot
	{
		internal ScreenshotHandle Value;

		public bool TagUser(SteamId user)
		{
			return SteamScreenshots.Internal.TagUser(Value, user);
		}

		public bool SetLocation(string location)
		{
			return SteamScreenshots.Internal.SetLocation(Value, location);
		}

		public bool TagPublishedFile(PublishedFileId file)
		{
			return SteamScreenshots.Internal.TagPublishedFile(Value, file);
		}
	}
	public struct ServerInfo : IEquatable<ServerInfo>
	{
		private string[] _tags;

		internal const uint k_unFavoriteFlagNone = 0u;

		internal const uint k_unFavoriteFlagFavorite = 1u;

		internal const uint k_unFavoriteFlagHistory = 2u;

		public string Name { get; set; }

		public int Ping { get; set; }

		public string GameDir { get; set; }

		public string Map { get; set; }

		public string Description { get; set; }

		public uint AppId { get; set; }

		public int Players { get; set; }

		public int MaxPlayers { get; set; }

		public int BotPlayers { get; set; }

		public bool Passworded { get; set; }

		public bool Secure { get; set; }

		public uint LastTimePlayed { get; set; }

		public int Version { get; set; }

		public string TagString { get; set; }

		public ulong SteamId { get; set; }

		public uint AddressRaw { get; set; }

		public IPAddress Address { get; set; }

		public int ConnectionPort { get; set; }

		public int QueryPort { get; set; }

		public string[] Tags
		{
			get
			{
				if (_tags == null && !string.IsNullOrEmpty(TagString))
				{
					_tags = TagString.Split(',');
				}
				return _tags;
			}
		}

		internal static ServerInfo From(gameserveritem_t item)
		{
			ServerInfo result = default(ServerInfo);
			result.AddressRaw = item.NetAdr.IP;
			result.Address = Utility.Int32ToIp(item.NetAdr.IP);
			result.ConnectionPort = item.NetAdr.ConnectionPort;
			result.QueryPort = item.NetAdr.QueryPort;
			result.Name = item.ServerNameUTF8();
			result.Ping = item.Ping;
			result.GameDir = item.GameDirUTF8();
			result.Map = item.MapUTF8();
			result.Description = item.GameDescriptionUTF8();
			result.AppId = item.AppID;
			result.Players = item.Players;
			result.MaxPlayers = item.MaxPlayers;
			result.BotPlayers = item.BotPlayers;
			result.Passworded = item.Password;
			result.Secure = item.Secure;
			result.LastTimePlayed = item.TimeLastPlayed;
			result.Version = item.ServerVersion;
			result.TagString = item.GameTagsUTF8();
			result.SteamId = item.SteamID;
			return result;
		}

		public ServerInfo(uint ip, ushort cport, ushort qport, uint timeplayed)
		{
			this = default(ServerInfo);
			AddressRaw = ip;
			Address = Utility.Int32ToIp(ip);
			ConnectionPort = cport;
			QueryPort = qport;
			LastTimePlayed = timeplayed;
		}

		public void AddToHistory()
		{
			SteamMatchmaking.Internal.AddFavoriteGame(SteamClient.AppId, AddressRaw, (ushort)ConnectionPort, (ushort)QueryPort, 2u, (uint)Epoch.Current);
		}

		public async Task<Dictionary<string, string>> QueryRulesAsync()
		{
			return await SourceServerQuery.GetRules(this);
		}

		public void RemoveFromHistory()
		{
			SteamMatchmaking.Internal.RemoveFavoriteGame(SteamClient.AppId, AddressRaw, (ushort)ConnectionPort, (ushort)QueryPort, 2u);
		}

		public void AddToFavourites()
		{
			SteamMatchmaking.Internal.AddFavoriteGame(SteamClient.AppId, AddressRaw, (ushort)ConnectionPort, (ushort)QueryPort, 1u, (uint)Epoch.Current);
		}

		public void RemoveFromFavourites()
		{
			SteamMatchmaking.Internal.RemoveFavoriteGame(SteamClient.AppId, AddressRaw, (ushort)ConnectionPort, (ushort)QueryPort, 1u);
		}

		public bool Equals(ServerInfo other)
		{
			return GetHashCode() == other.GetHashCode();
		}

		public override int GetHashCode()
		{
			return Address.GetHashCode() + SteamId.GetHashCode() + ConnectionPort.GetHashCode() + QueryPort.GetHashCode();
		}
	}
	public struct Stat
	{
		public string Name { get; internal set; }

		public SteamId UserId { get; internal set; }

		public Stat(string name)
		{
			Name = name;
			UserId = 0uL;
		}

		public Stat(string name, SteamId user)
		{
			Name = name;
			UserId = user;
		}

		internal void LocalUserOnly([CallerMemberName] string caller = null)
		{
			if ((ulong)UserId == 0L)
			{
				return;
			}
			throw new Exception("Stat." + caller + " can only be called for the local user");
		}

		public double GetGlobalFloat()
		{
			double pData = 0.0;
			if (SteamUserStats.Internal.GetGlobalStat(Name, ref pData))
			{
				return pData;
			}
			return 0.0;
		}

		public long GetGlobalInt()
		{
			long pData = 0L;
			SteamUserStats.Internal.GetGlobalStat(Name, ref pData);
			return pData;
		}

		public async Task<long[]> GetGlobalIntDaysAsync(int days)
		{
			GlobalStatsReceived_t? globalStatsReceived_t = await SteamUserStats.Internal.RequestGlobalStats(days);
			if (!globalStatsReceived_t.HasValue || globalStatsReceived_t.GetValueOrDefault().Result != Result.OK)
			{
				return null;
			}
			long[] array = new long[days];
			int globalStatHistory = SteamUserStats.Internal.GetGlobalStatHistory(Name, array, (uint)(array.Length * 8));
			if (days != globalStatHistory)
			{
				array = array.Take(globalStatHistory).ToArray();
			}
			return array;
		}

		public async Task<double[]> GetGlobalFloatDays(int days)
		{
			GlobalStatsReceived_t? globalStatsReceived_t = await SteamUserStats.Internal.RequestGlobalStats(days);
			if (!globalStatsReceived_t.HasValue || globalStatsReceived_t.GetValueOrDefault().Result != Result.OK)
			{
				return null;
			}
			double[] array = new double[days];
			int globalStatHistory = SteamUserStats.Internal.GetGlobalStatHistory(Name, array, (uint)(array.Length * 8));
			if (days != globalStatHistory)
			{
				array = array.Take(globalStatHistory).ToArray();
			}
			return array;
		}

		public float GetFloat()
		{
			float pData = 0f;
			if ((ulong)UserId != 0)
			{
				SteamUserStats.Internal.GetUserStat(UserId, Name, ref pData);
			}
			else
			{
				SteamUserStats.Internal.GetStat(Name, ref pData);
			}
			return 0f;
		}

		public int GetInt()
		{
			int pData = 0;
			if ((ulong)UserId != 0)
			{
				SteamUserStats.Internal.GetUserStat(UserId, Name, ref pData);
			}
			else
			{
				SteamUserStats.Internal.GetStat(Name, ref pData);
			}
			return pData;
		}

		public bool Set(int val)
		{
			LocalUserOnly("Set");
			return SteamUserStats.Internal.SetStat(Name, val);
		}

		public bool Set(float val)
		{
			LocalUserOnly("Set");
			return SteamUserStats.Internal.SetStat(Name, val);
		}

		public bool Add(int val)
		{
			LocalUserOnly("Add");
			return Set(GetInt() + val);
		}

		public bool Add(float val)
		{
			LocalUserOnly("Add");
			return Set(GetFloat() + val);
		}

		public bool UpdateAverageRate(float count, float sessionlength)
		{
			LocalUserOnly("UpdateAverageRate");
			return SteamUserStats.Internal.UpdateAvgRateStat(Name, count, sessionlength);
		}

		public bool Store()
		{
			LocalUserOnly("Store");
			return SteamUserStats.Internal.StoreStats();
		}
	}
	public struct Ugc
	{
		internal UGCHandle_t Handle;
	}
}