using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.IL2CPP;
using BepInEx.IL2CPP.Utils;
using BepInEx.Logging;
using CodeStage.AntiCheat.ObscuredTypes;
using CrabDevKit.Intermediary;
using CrabDevKit.Utilities;
using HarmonyLib;
using Il2CppSystem;
using Il2CppSystem.Collections;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Collections.ObjectModel;
using Il2CppSystem.IO;
using Il2CppSystem.Runtime.InteropServices;
using Il2CppSystem.Text;
using Il2CppSystem.Text.RegularExpressions;
using Microsoft.CodeAnalysis;
using MilkShake;
using SteamworksNative;
using TMPro;
using UnhollowerBaseLib;
using UnhollowerRuntimeLib;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Rendering.PostProcessing;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class ParamCollectionAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CrabDevKit
{
	internal static class Patches
	{
		[HarmonyPatch(typeof(MonoBehaviourPublicGataInefObInUnique), "Method_Private_Void_GameObject_Boolean_Vector3_Quaternion_0")]
		[HarmonyPatch(typeof(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique), "Method_Private_Void_0")]
		[HarmonyPrefix]
		internal static bool PreBepinexDetection()
		{
			return false;
		}
	}
	[BepInPlugin("lammas123.CrabDevKit", "CrabDevKit", "1.2.1")]
	public sealed class CrabDevKit : BasePlugin
	{
		internal static CrabDevKit Instance { get; private set; }

		internal static CrabNet CrabNet { get; private set; }

		public override void Load()
		{
			//IL_0042: 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_0067: Expected O, but got Unknown
			CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
			CultureInfo.CurrentUICulture = CultureInfo.InvariantCulture;
			CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
			CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
			Instance = this;
			CrabNet = new CrabNet();
			FakeClients.Init();
			new Harmony("CrabDevKit").PatchAll(typeof(Patches));
			ManualLogSource log = ((BasePlugin)this).Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(15, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Initialized [");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("CrabDevKit");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("1.2.1");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("]");
			}
			log.LogInfo(val);
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "lammas123.CrabDevKit";

		public const string PLUGIN_NAME = "CrabDevKit";

		public const string PLUGIN_VERSION = "1.2.1";
	}
}
namespace CrabDevKit.Utilities
{
	public sealed class AssetBundlePtr : IDisposable
	{
		internal IntPtr bundlePtr;

		private bool _disposed;

		internal AssetBundlePtr(IntPtr intPtr)
		{
			bundlePtr = intPtr;
		}

		~AssetBundlePtr()
		{
			Unload(unloadAllLoadedObjects: true);
		}

		public void Dispose()
		{
			Unload(unloadAllLoadedObjects: true);
		}

		public static AssetBundlePtr LoadFromFile(string path, uint crc = 0u, ulong offset = 0uL)
		{
			if (string.IsNullOrEmpty(path))
			{
				throw new ArgumentNullException("path", "The asset bundle file path cannot be null.");
			}
			if (!File.Exists(path))
			{
				throw new FileNotFoundException("The asset bundle file path does not point to a file that exists.", path);
			}
			if (offset > long.MaxValue)
			{
				throw new ArgumentOutOfRangeException("offset", "Offset is greater than long.MaxValue. (Why?)");
			}
			using FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
			if ((long)offset >= fileStream.Length)
			{
				throw new ArgumentOutOfRangeException("offset", "Offset is beyond end of file.");
			}
			fileStream.Seek((long)offset, SeekOrigin.Begin);
			long num = fileStream.Length - (long)offset;
			byte[] array = new byte[num];
			int num2 = fileStream.Read(array, 0, array.Length);
			if (num2 != num)
			{
				throw new IOException($"Expected {num} bytes, but read {num2}.");
			}
			return LoadFromMemory(array, crc);
		}

		public static AssetBundlePtr LoadFromMemory(byte[] binary, uint crc = 0u)
		{
			return AssetBundleManager.LoadBundle(binary, crc);
		}

		public bool Contains(string name)
		{
			if (_disposed)
			{
				return false;
			}
			if (string.IsNullOrEmpty(name))
			{
				throw new ArgumentNullException("name", "The input asset name cannot be null or empty.");
			}
			AssetBundleManager.MakeCurrentBundle(this);
			return AssetBundle.ContainsDelegateField.Invoke(bundlePtr, IL2CPP.ManagedStringToIl2Cpp(name));
		}

		public string[] GetAllAssetNames()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			if (_disposed)
			{
				return null;
			}
			AssetBundleManager.MakeCurrentBundle(this);
			IntPtr intPtr = AssetBundle.GetAllAssetNamesDelegateField.Invoke(bundlePtr);
			if (!(intPtr == IntPtr.Zero))
			{
				return ((IEnumerable<string>)new Il2CppStringArray(intPtr)).ToArray();
			}
			return null;
		}

		public string[] GetAllScenePaths()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			if (_disposed)
			{
				return null;
			}
			AssetBundleManager.MakeCurrentBundle(this);
			IntPtr intPtr = AssetBundle.GetAllScenePathsDelegateField.Invoke(bundlePtr);
			if (!(intPtr == IntPtr.Zero))
			{
				return ((IEnumerable<string>)new Il2CppStringArray(intPtr)).ToArray();
			}
			return null;
		}

		public void Unload(bool unloadAllLoadedObjects)
		{
			if (!_disposed)
			{
				AssetBundleManager.MakeCurrentBundle(this);
				AssetBundleManager.DisposeCurrentBundle(unloadAllLoadedObjects);
				GC.SuppressFinalize(this);
				_disposed = true;
			}
		}

		public Object[] LoadAllAssets(Type type)
		{
			if (_disposed)
			{
				return null;
			}
			if (type == null)
			{
				throw new ArgumentNullException("type", "The input type cannot be null.");
			}
			AssetBundleManager.MakeCurrentBundle(this);
			Type val = Il2CppType.From(type);
			IntPtr intPtr = AssetBundle.LoadAssetWithSubAssets_InternalDelegateField.Invoke(bundlePtr, IL2CPP.ManagedStringToIl2Cpp(string.Empty), IL2CPP.Il2CppObjectBaseToPtr((Il2CppObjectBase)(object)val));
			if (!(intPtr == IntPtr.Zero))
			{
				return ((IEnumerable<Object>)new Il2CppReferenceArray<Object>(intPtr)).ToArray();
			}
			return null;
		}

		public Object[] LoadAllAssets<T>() where T : Object
		{
			return LoadAllAssets(typeof(T));
		}

		public Object LoadAsset(string name, Type type)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			if (_disposed)
			{
				return null;
			}
			if (string.IsNullOrEmpty(name))
			{
				throw new ArgumentNullException("name", "The input asset name cannot be null or empty.");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type", "The input type cannot be null.");
			}
			AssetBundleManager.MakeCurrentBundle(this);
			Type val = Il2CppType.From(type);
			IntPtr intPtr = AssetBundle.LoadAsset_InternalDelegateField.Invoke(bundlePtr, IL2CPP.ManagedStringToIl2Cpp(name), IL2CPP.Il2CppObjectBaseToPtr((Il2CppObjectBase)(object)val));
			if (!(intPtr == IntPtr.Zero))
			{
				return new Object(intPtr);
			}
			return null;
		}

		public Object LoadAsset<T>(string name) where T : Object
		{
			return LoadAsset(name, typeof(T));
		}
	}
	internal static class AssetBundleManager
	{
		internal static Dictionary<AssetBundlePtr, (Il2CppStructArray<byte>, uint)> managedBundles = new Dictionary<AssetBundlePtr, (Il2CppStructArray<byte>, uint)>();

		internal static AssetBundlePtr currentBundle;

		internal static AssetBundlePtr LoadBundle(byte[] binary, uint crc)
		{
			MakeCurrentBundle(null);
			Il2CppStructArray<byte> val = new Il2CppStructArray<byte>(binary);
			IntPtr intPtr = AssetBundle.LoadFromMemory_InternalDelegateField.Invoke(IL2CPP.Il2CppObjectBaseToPtr((Il2CppObjectBase)(object)val), crc);
			if (intPtr == IntPtr.Zero)
			{
				throw new NullReferenceException("Failed to load the bundle. The bundle may not be valid, idk ask Unity lol.");
			}
			currentBundle = new AssetBundlePtr(intPtr);
			managedBundles.Add(currentBundle, (val, crc));
			return currentBundle;
		}

		internal static void MakeCurrentBundle(AssetBundlePtr bundle)
		{
			if (bundle == currentBundle)
			{
				return;
			}
			if (currentBundle != null)
			{
				UnloadCurrentBundle();
			}
			if (bundle != null)
			{
				IntPtr intPtr = AssetBundle.LoadFromMemory_InternalDelegateField.Invoke(IL2CPP.Il2CppObjectBaseToPtr((Il2CppObjectBase)(object)managedBundles[bundle].Item1), managedBundles[bundle].Item2);
				if (intPtr == IntPtr.Zero)
				{
					throw new NullReferenceException("Failed to make bundle the current bundle, odd. It didn't fail previously, so it should be valid, but maybe something went wrong with unloading the previous bundle.");
				}
				bundle.bundlePtr = intPtr;
				currentBundle = bundle;
			}
		}

		internal static void DisposeCurrentBundle(bool unloadAllLoadedObjects = false)
		{
			managedBundles.Remove(currentBundle);
			UnloadCurrentBundle(unloadAllLoadedObjects);
		}

		internal static void UnloadCurrentBundle(bool unloadAllLoadedObjects = false)
		{
			AssetBundle.UnloadDelegateField.Invoke(currentBundle.bundlePtr, unloadAllLoadedObjects);
			currentBundle.bundlePtr = IntPtr.Zero;
			currentBundle = null;
		}
	}
	public static class ChatUtil
	{
		public enum MessageType
		{
			Normal,
			Server,
			Styled
		}

		public static int MaxMessageLength
		{
			get
			{
				if (!((Object)(object)MonoBehaviourPublicRaovTMinTemeColoonCoUnique.Instance != (Object)null))
				{
					return 80;
				}
				return MonoBehaviourPublicRaovTMinTemeColoonCoUnique.Instance.get_maxMsgLength();
			}
		}

		public static int MaxConsecutiveChars
		{
			get
			{
				if (!((Object)(object)MonoBehaviourPublicRaovTMinTemeColoonCoUnique.Instance != (Object)null))
				{
					return 5;
				}
				return MonoBehaviourPublicRaovTMinTemeColoonCoUnique.Instance.get_deobf_maxConsecutiveChars();
			}
		}

		public static string FormatMessage(string str)
		{
			return Regex.Replace(str, $"(.)(?<=\\1{{{MaxConsecutiveChars}}})", string.Empty, RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.CultureInvariant);
		}

		public static void SendMessage(ulong recipientClientId, string message, MessageType messageType = MessageType.Server, string displayName = null)
		{
			SendMessage(message, messageType, displayName, new <>z__ReadOnlySingleElementList<ulong>(recipientClientId));
		}

		public static void SendMessage(string message, MessageType messageType = MessageType.Server, string displayName = null, IEnumerable<ulong> recipientClientIds = null)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			ulong value = 0uL;
			message = FormatMessage(message ?? string.Empty);
			if (messageType == MessageType.Server)
			{
				displayName = string.Empty;
				value = 1uL;
			}
			else if (displayName == null)
			{
				displayName = string.Empty;
			}
			ObjectPublicIDisposableLi1ByInByBoUnique val = new ObjectPublicIDisposableLi1ByInByBoUnique(2);
			val.Write(value);
			val.Write(displayName);
			val.Write(message);
			val.WriteLength();
			IEnumerable<ulong> enumerable = recipientClientIds;
			if (enumerable == null)
			{
				KeyCollection<ulong, int> keys = MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.steamIdToUID.Keys;
				int num = 0;
				ulong[] array = new ulong[keys.Count];
				Enumerator<ulong, int> enumerator = keys.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ulong current = enumerator.Current;
					array[num] = current;
					num++;
				}
				enumerable = new <>z__ReadOnlyArray<ulong>(array);
			}
			foreach (ulong item in enumerable)
			{
				if (messageType == MessageType.Styled)
				{
					byte[] bytes = BitConverter.GetBytes(item);
					for (int i = 0; i < bytes.Length; i++)
					{
						val.field_Private_List_1_Byte_0[i + 8] = bytes[i];
					}
				}
				MonoBehaviourPublicInStInpabyDiInpaby2Unique.SendPacket(new CSteamID(item), val, ServerSendExtensions.get_deobf_reliable(), (EnumNPublicSealedvaTo3vToUnique)0);
			}
			val.Dispose();
		}

		public static string[] FormatGameModeDescription(string description)
		{
			List<string> list = description.Split('\n', StringSplitOptions.RemoveEmptyEntries).ToList();
			for (int i = 0; i < list.Count; i++)
			{
				list[i] = list[i].Replace('•', '*');
				while (list[i].Length > MaxMessageLength)
				{
					int num = list[i].LastIndexOf(' ', MaxMessageLength - 1, 20);
					if (num == -1)
					{
						num = MaxMessageLength;
					}
					int index = i + 1;
					string text = list[i];
					int num2 = num;
					list.Insert(index, text.Substring(num2, text.Length - num2));
					list[i] = list[i].Substring(0, num);
				}
			}
			return list.ToArray();
		}
	}
	public sealed class CrabNet
	{
		public delegate void MessageHandler(ulong clientId, ObjectPublicIDisposableLi1ByInByBoUnique packet);

		internal static class Patches
		{
			private static readonly Il2CppStructArray<IntPtr> _messagePtrs = new Il2CppStructArray<IntPtr>(70L);

			[HarmonyPatch(typeof(MonoBehaviourPublicInStInpabyDiInpaby2Unique), "CheckForPackets")]
			[HarmonyPostfix]
			internal static void PostSteamPacketManagerCheckForPackets()
			{
				int num;
				do
				{
					num = SteamNetworkingMessages.ReceiveMessagesOnChannel(123, _messagePtrs, 70);
					if (num == 0)
					{
						break;
					}
					for (int i = 0; i < num; i++)
					{
						SteamNetworkingMessage_t message = Marshal.PtrToStructure<SteamNetworkingMessage_t>(((Il2CppArrayBase<IntPtr>)(object)_messagePtrs)[i]);
						CrabDevKit.CrabNet.HandleMessage(message);
					}
				}
				while (num == 70);
			}

			[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "Method_Private_Void_LobbyEnter_t_PDM_1")]
			[HarmonyPostfix]
			[HarmonyPriority(int.MaxValue)]
			internal static void PostSteamManagerLobbyEnter(LobbyEnter_t param_1)
			{
				//IL_0005: 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 (MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.get_currentLobby().m_SteamID == param_1.m_ulSteamIDLobby)
				{
					CrabDevKit.CrabNet.RegisterMessageHandlers();
				}
			}
		}

		private uint _nextId;

		private readonly Dictionary<string, uint> _registeredMessageHandlers = new Dictionary<string, uint>();

		private readonly Dictionary<uint, MessageHandler> _messageHandlers = new Dictionary<uint, MessageHandler>();

		private const int SendFlag = 8;

		private const int MessageChannel = 123;

		private const int MessagesPerFrame = 70;

		internal CrabNet()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			new Harmony("CrabDevKit.CrabNet").PatchAll(typeof(Patches));
		}

		public static bool RegisterMessageHandler(string messageId, MessageHandler messageHandler)
		{
			if (CrabDevKit.CrabNet == null)
			{
				throw new InvalidOperationException("CrabNet has yet to be initialized. Ensure your plugin is depending on CrabDevKit, so that it initializes CrabNet before you use it!");
			}
			if (string.IsNullOrEmpty(messageId))
			{
				throw new ArgumentNullException("messageId", "messageId may not be null or empty.");
			}
			if (!messageId.Contains(':'))
			{
				throw new ArgumentException("A colon ':' separator character was expected in the messageId parameter. Your messageId should follow this format -> PluginName:MessageId", "messageId");
			}
			if (messageHandler == null)
			{
				throw new ArgumentNullException("messageHandler");
			}
			return CrabDevKit.CrabNet.RegisterMessageHandlerInternal(messageId, messageHandler);
		}

		private bool RegisterMessageHandlerInternal(string messageId, MessageHandler messageHandler)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			if (string.IsNullOrEmpty(messageId))
			{
				throw new ArgumentNullException("messageId", "messageId may not be null or empty.");
			}
			if (messageHandler == null)
			{
				throw new ArgumentNullException("messageHandler");
			}
			if (Object.op_Implicit((Object)(object)MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance))
			{
				((BasePlugin)CrabDevKit.Instance).Log.LogWarning((object)"Message handlers must be registered on plugin load!");
				return false;
			}
			bool flag = default(bool);
			if (_registeredMessageHandlers.ContainsKey(messageId))
			{
				ManualLogSource log = ((BasePlugin)CrabDevKit.Instance).Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(34, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Message handler '");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(messageId);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' already exists!");
				}
				log.LogWarning(val);
				return false;
			}
			uint nextId = _nextId;
			_nextId++;
			_registeredMessageHandlers.Add(messageId, nextId);
			_messageHandlers.Add(nextId, messageHandler);
			ManualLogSource log2 = ((BasePlugin)CrabDevKit.Instance).Log;
			BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(31, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Registered message handler: ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(messageId);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" (");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<uint>(nextId);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(")");
			}
			log2.LogInfo(val2);
			return true;
		}

		private void RegisterMessageHandlers()
		{
			//IL_0005: 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_000b: 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)
			CSteamID val = MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.get_currentLobby();
			SteamMatchmaking.SetLobbyMemberData(val, "CrabNetVersion", "1.2.1");
			foreach (var (text2, num2) in _registeredMessageHandlers)
			{
				SteamMatchmaking.SetLobbyMemberData(val, $"CrabNet:Message.{num2}", text2);
			}
			((BasePlugin)CrabDevKit.Instance).Log.LogInfo((object)"Registered message handlers for lobby.");
		}

		public static bool SendMessage(string messageId, ObjectPublicIDisposableLi1ByInByBoUnique packet, [ParamCollection] IEnumerable<ulong> clientIds)
		{
			if (CrabDevKit.CrabNet == null)
			{
				throw new InvalidOperationException("CrabNet has yet to be initialized. Ensure your plugin is depending on CrabDevKit, so that it initializes CrabNet before you use it!");
			}
			if (string.IsNullOrEmpty(messageId))
			{
				throw new ArgumentNullException("messageId", "messageId may not be null or empty.");
			}
			if (packet == null)
			{
				throw new ArgumentNullException("packet");
			}
			if (clientIds == null)
			{
				throw new ArgumentNullException("clientIds");
			}
			return CrabDevKit.CrabNet.SendMessageInternal(messageId, packet, clientIds.Select((Func<ulong, CSteamID>)((ulong clientId) => new CSteamID(clientId))));
		}

		public static bool SendMessage(string messageId, ObjectPublicIDisposableLi1ByInByBoUnique packet, [ParamCollection] IEnumerable<CSteamID> steamIds)
		{
			if (CrabDevKit.CrabNet == null)
			{
				throw new InvalidOperationException("CrabNet has yet to be initialized. Ensure your plugin is depending on CrabDevKit, so that it initializes CrabNet before you use it!");
			}
			if (string.IsNullOrEmpty(messageId))
			{
				throw new ArgumentNullException("messageId", "messageId may not be null or empty.");
			}
			if (packet == null)
			{
				throw new ArgumentNullException("packet");
			}
			if (steamIds == null)
			{
				throw new ArgumentNullException("steamIds");
			}
			return CrabDevKit.CrabNet.SendMessageInternal(messageId, packet, steamIds);
		}

		private bool SendMessageInternal(string messageId, ObjectPublicIDisposableLi1ByInByBoUnique packet, IEnumerable<CSteamID> steamIds)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//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_00b5: 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_0105: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_0136: 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_0125: Expected O, but got Unknown
			//IL_0126: 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)
			if (string.IsNullOrEmpty(messageId))
			{
				throw new ArgumentNullException("messageId", "messageId may not be null or empty.");
			}
			if (packet == null)
			{
				throw new ArgumentNullException("packet");
			}
			if (steamIds == null)
			{
				throw new ArgumentNullException("steamIds");
			}
			bool flag = default(bool);
			if (!_registeredMessageHandlers.TryGetValue(messageId, out var value))
			{
				ManualLogSource log = ((BasePlugin)CrabDevKit.Instance).Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(34, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Message handler '");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(messageId);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' does not exist!");
				}
				log.LogWarning(val);
				return false;
			}
			ObjectPublicIDisposableLi1ByInByBoUnique val2 = new ObjectPublicIDisposableLi1ByInByBoUnique();
			val2.Write((int)value);
			val2.Write(packet.CloneBytes());
			foreach (CSteamID steamId in steamIds)
			{
				if (string.IsNullOrEmpty(SteamMatchmaking.GetLobbyMemberData(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.get_currentLobby(), steamId, "CrabNetVersion")))
				{
					ManualLogSource log2 = ((BasePlugin)CrabDevKit.Instance).Log;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(52, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<ulong>(steamId.m_SteamID);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" does not have CrabNet, and cannot receive messages!");
					}
					log2.LogWarning(val);
				}
				else if (steamId == SteamUser.GetSteamID())
				{
					ObjectPublicIDisposableLi1ByInByBoUnique packet2 = new ObjectPublicIDisposableLi1ByInByBoUnique(Il2CppStructArray<byte>.op_Implicit(val2.CloneBytes()));
					HandleMessage(steamId.m_SteamID, packet2);
				}
				else
				{
					MonoBehaviourPublicInStInpabyDiInpaby2Unique.SendPacket(steamId, val2, 8, (EnumNPublicSealedvaTo3vToUnique)123);
				}
			}
			val2.Dispose();
			packet.Dispose();
			return true;
		}

		private void HandleMessage(SteamNetworkingMessage_t message)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			ulong steamID = message.m_identityPeer.GetSteamID64();
			int cbSize = message.m_cbSize;
			IntPtr pData = message.m_pData;
			Il2CppStructArray<byte> val = new Il2CppStructArray<byte>((long)cbSize);
			Marshal.Copy(pData, val, 0, cbSize);
			ObjectPublicIDisposableLi1ByInByBoUnique val2 = new ObjectPublicIDisposableLi1ByInByBoUnique();
			val2.SetBytes(Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)val));
			HandleMessage(steamID, val2);
		}

		private void HandleMessage(ulong clientId, ObjectPublicIDisposableLi1ByInByBoUnique packet)
		{
			//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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			bool flag = default(bool);
			try
			{
				uint value = (uint)packet.ReadInt();
				string lobbyMemberData = SteamMatchmaking.GetLobbyMemberData(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.get_currentLobby(), new CSteamID(clientId), $"CrabNet:Message.{value}");
				if (string.IsNullOrEmpty(lobbyMemberData))
				{
					ManualLogSource log = ((BasePlugin)CrabDevKit.Instance).Log;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(37, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Unable to identify messageId from '");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<uint>(value);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("'!");
					}
					log.LogWarning(val);
				}
				else if (!_registeredMessageHandlers.TryGetValue(lobbyMemberData, out value))
				{
					ManualLogSource log2 = ((BasePlugin)CrabDevKit.Instance).Log;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(16, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(lobbyMemberData);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" is not defined!");
					}
					log2.LogWarning(val);
				}
				else
				{
					_messageHandlers[value](clientId, packet);
					packet.Dispose();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log3 = ((BasePlugin)CrabDevKit.Instance).Log;
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(42, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("An exception occurred handling a message:\n");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<Exception>(ex);
				}
				log3.LogError(val2);
			}
		}
	}
	public static class DimensionalArrayUtil
	{
		public static T[,] ToManaged2D<T>(Il2CppObjectBase il2CppArray)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			if (il2CppArray == null || il2CppArray.Pointer == IntPtr.Zero)
			{
				throw new ArgumentNullException("il2CppArray");
			}
			Array val = new Array(il2CppArray.Pointer);
			if (val.Rank != 2)
			{
				throw new InvalidOperationException($"Expected rank-2 array, got rank {val.Rank}");
			}
			int length = val.GetLength(0);
			int length2 = val.GetLength(1);
			T[,] array = new T[length, length2];
			for (int i = 0; i < length; i++)
			{
				for (int j = 0; j < length2; j++)
				{
					object value = val.GetValue(i, j);
					Il2CppObjectBase val2 = (Il2CppObjectBase)((value is Il2CppObjectBase) ? value : null);
					if (val2 != null && typeof(T).IsAssignableFrom(((object)val2).GetType()))
					{
						array[i, j] = (T)(object)val2;
					}
					else if (value != null)
					{
						array[i, j] = (T)Convert.ChangeType(value, typeof(T));
					}
					else
					{
						array[i, j] = default(T);
					}
				}
			}
			return array;
		}

		public static Il2CppObjectBase FromManaged2D<T>(T[,] managed)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected O, but got Unknown
			if (managed == null)
			{
				throw new ArgumentNullException("managed");
			}
			int length = managed.GetLength(0);
			int length2 = managed.GetLength(1);
			IntPtr nativeClassPtr = Il2CppClassPointerStore<T>.NativeClassPtr;
			if (nativeClassPtr == IntPtr.Zero)
			{
				throw new InvalidOperationException($"Type {typeof(T)} is not defined in IL2CPP.");
			}
			IntPtr intPtr = CreateArray(nativeClassPtr, new int[2] { length, length2 });
			Array val = new Array(intPtr);
			for (int i = 0; i < length; i++)
			{
				for (int j = 0; j < length2; j++)
				{
					object obj = managed[i, j];
					if (obj == null)
					{
						val.SetValue((Object)null, i, j);
						continue;
					}
					Il2CppObjectBase val2 = (Il2CppObjectBase)((obj is Il2CppObjectBase) ? obj : null);
					if (val2 != null)
					{
						val.SetValue(val2.TryCast<Object>(), i, j);
						continue;
					}
					if (obj is string text)
					{
						IntPtr intPtr2 = IL2CPP.ManagedStringToIl2Cpp(text);
						val.SetValue((Object)new String(intPtr2), i, j);
						continue;
					}
					if (obj.GetType().IsValueType)
					{
						IntPtr intPtr3 = Marshal.AllocHGlobal(Marshal.SizeOf(obj.GetType()));
						Marshal.StructureToPtr(obj, intPtr3, fDeleteOld: false);
						IntPtr intPtr4 = IL2CPP.il2cpp_value_box(nativeClassPtr, intPtr3);
						Marshal.FreeHGlobal(intPtr3);
						val.SetValue(new Object(intPtr4), i, j);
						continue;
					}
					throw new NotImplementedException($"Unable to box type {obj.GetType()}.");
				}
			}
			return new Il2CppObjectBase(intPtr);
		}

		private static IntPtr CreateArray(IntPtr elementClass, int[] dims)
		{
			if (dims == null || dims.Length == 0)
			{
				throw new ArgumentException("dims");
			}
			int num = dims.Length;
			ulong[] array = new ulong[num];
			ulong[] array2 = new ulong[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = (ulong)dims[i];
				array2[i] = 0uL;
			}
			return IL2CPP.il2cpp_array_new_full(elementClass, ref array[0], ref array2[0]);
		}
	}
	public static class FakeClients
	{
		internal static class Patches
		{
			[HarmonyPatch(typeof(SteamMatchmaking), "LeaveLobby")]
			[HarmonyPostfix]
			internal static void PostSteamMatchmakingLeaveLobby()
			{
				fakeClientIds.Clear();
				fakeClients.Clear();
			}

			[HarmonyPatch(typeof(SteamMatchmaking), "GetNumLobbyMembers")]
			[HarmonyPostfix]
			internal static void PostSteamMatchmakingGetNumLobbyMembers(ref int __result)
			{
				__result += fakeClients.Count;
			}

			[HarmonyPatch(typeof(SteamMatchmaking), "GetLobbyMemberByIndex")]
			[HarmonyPrefix]
			internal static bool PreSteamMatchmakingGetLobbyMemberByIndex(CSteamID steamIDLobby, int iMember, ref CSteamID __result)
			{
				//IL_0000: 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)
				int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(steamIDLobby);
				int count = fakeClients.Count;
				int num = numLobbyMembers - count;
				if (iMember >= num && iMember < numLobbyMembers)
				{
					__result = new CSteamID(fakeClients[iMember - num].clientId);
					return false;
				}
				return true;
			}

			[HarmonyPatch(typeof(SteamMatchmaking), "GetLobbyMemberData")]
			[HarmonyPrefix]
			internal static bool PreSteamMatchmakingGetLobbyMemberData(CSteamID steamIDUser, string pchKey, ref string __result)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				if (fakeClientIds.TryGetValue(steamIDUser.m_SteamID, out var value))
				{
					__result = (value.memberData.TryGetValue(pchKey, out var value2) ? value2 : __result);
					return false;
				}
				return true;
			}

			[HarmonyPatch(typeof(SteamFriends), "GetFriendPersonaName")]
			[HarmonyPrefix]
			internal static bool PreSteamFriendsGetFriendPersonaName(CSteamID steamIDFriend, ref string __result)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				if (fakeClientIds.TryGetValue(steamIDFriend.m_SteamID, out var value))
				{
					__result = value.name;
					return false;
				}
				return true;
			}

			[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "NewAcceptP2P", new Type[] { typeof(SteamNetworkingIdentity) })]
			[HarmonyPrefix]
			internal static bool PreSteamManagerNewAcceptP2PIdentityRemote(SteamNetworkingIdentity param_1)
			{
				return !fakeClientIds.ContainsKey(param_1.GetSteamID64());
			}

			[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "NewAcceptP2P", new Type[] { typeof(CSteamID) })]
			[HarmonyPrefix]
			internal static bool PreSteamManagerNewAcceptP2PCSteamID(CSteamID param_1)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				return !fakeClientIds.ContainsKey(param_1.m_SteamID);
			}

			[HarmonyPatch(typeof(MonoBehaviourPublicInStInpabyDiInpaby2Unique), "SendPacket")]
			[HarmonyPrefix]
			internal static bool PreSteamPacketManagerSendPacket(CSteamID param_0)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				return !fakeClientIds.ContainsKey(param_0.m_SteamID);
			}

			[HarmonyPatch(typeof(MonoBehaviourPublicInInUnique), "LoadMap", new Type[]
			{
				typeof(int),
				typeof(int)
			})]
			[HarmonyPostfix]
			internal static void PostServerSendLoadMap()
			{
				foreach (FakeClient fakeClient in fakeClients)
				{
					fakeClient.FakeLoad();
				}
			}

			[HarmonyPatch(typeof(MonoBehaviourPublicInInUnique), "LoadMap", new Type[]
			{
				typeof(int),
				typeof(int),
				typeof(ulong)
			})]
			[HarmonyPrefix]
			internal static bool PreServerSendLoadMap(ulong param_2)
			{
				if (fakeClientIds.TryGetValue(param_2, out var value))
				{
					value.FakeLoad();
					return false;
				}
				return true;
			}

			[HarmonyPatch(typeof(MonoBehaviourPublicDi2UIObacspDi2UIObUnique), "Start")]
			[HarmonyPostfix]
			internal static void PostGameManagerStart()
			{
				foreach (FakeClient fakeClient in fakeClients)
				{
					fakeClient.FakeSpawn();
				}
			}
		}

		internal const ulong MIN_ID = 10uL;

		private static readonly Dictionary<ulong, FakeClient> fakeClientIds = new Dictionary<ulong, FakeClient>();

		private static readonly List<FakeClient> fakeClients = new List<FakeClient>();

		internal static void Init()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new Harmony("CrabDevKit.FakeClients").PatchAll(typeof(Patches));
		}

		public static FakeClient Create(string name = null, bool streamerMode = false, bool forceSpawnActive = false)
		{
			//IL_0056: 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_008a: 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_0091: 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_00ad: Expected O, but got Unknown
			if (!MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner())
			{
				return null;
			}
			ulong num;
			for (num = 10uL; MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.steamIdToUID.ContainsKey(num) || fakeClientIds.ContainsKey(num); num++)
			{
			}
			FakeClient fakeClient = new FakeClient(num, name, streamerMode, forceSpawnActive);
			fakeClientIds.Add(num, fakeClient);
			fakeClients.Add(fakeClient);
			LobbyChatUpdate_t val = default(LobbyChatUpdate_t);
			val.m_ulSteamIDLobby = MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.get_currentLobby().m_SteamID;
			val.m_ulSteamIDUserChanged = num;
			val.m_ulSteamIDMakingChange = num;
			val.m_rgfChatMemberStateChange = 1u;
			LobbyChatUpdate_t ev = val;
			MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.PlayerJoinOrLeave(ev);
			ManualLogSource log = ((BasePlugin)CrabDevKit.Instance).Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(21, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Created fake client: ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<ulong>(num);
			}
			log.LogInfo(val2);
			return fakeClient;
		}

		public static void Remove(FakeClient fakeClient)
		{
			//IL_0021: 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_005f: 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_0066: 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_00ad: Expected O, but got Unknown
			if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner() && fakeClientIds.ContainsKey(fakeClient.clientId))
			{
				LobbyChatUpdate_t val = default(LobbyChatUpdate_t);
				val.m_ulSteamIDLobby = MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.get_currentLobby().m_SteamID;
				val.m_ulSteamIDUserChanged = fakeClient.clientId;
				val.m_ulSteamIDMakingChange = fakeClient.clientId;
				val.m_rgfChatMemberStateChange = 2u;
				LobbyChatUpdate_t ev = val;
				MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.PlayerJoinOrLeave(ev);
				fakeClients.Remove(fakeClientIds[fakeClient.clientId]);
				fakeClientIds.Remove(fakeClient.clientId);
				ManualLogSource log = ((BasePlugin)CrabDevKit.Instance).Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(21, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Removed fake client: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<ulong>(fakeClient.clientId);
				}
				log.LogInfo(val2);
			}
		}
	}
	public sealed class FakeClient
	{
		public readonly ulong clientId;

		public readonly string name;

		public readonly bool streamerMode;

		private bool _forceSpawnActive;

		public readonly Dictionary<string, string> memberData = new Dictionary<string, string>();

		internal FakeClient(ulong fakeClientId, string name = null, bool streamerMode = false, bool forceSpawnActive = false)
		{
			clientId = fakeClientId;
			this.name = (string.IsNullOrEmpty(name) ? $"FakeClient {clientId - 10 + 1}" : name);
			this.streamerMode = streamerMode;
			_forceSpawnActive = forceSpawnActive;
		}

		internal void FakeLoad()
		{
			MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique.StartedLoading(clientId, (ObjectPublicIDisposableLi1ByInByBoUnique)null);
			MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique.LoadingRequestEnterGame(clientId, (ObjectPublicIDisposableLi1ByInByBoUnique)null);
			if (Object.op_Implicit((Object)(object)MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance))
			{
				FakeSpawn();
			}
		}

		internal void FakeSpawn()
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			if (!MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers.ContainsKey(clientId) && !MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.spectators.ContainsKey(clientId))
			{
				MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique.GameModeLoaded(clientId, (ObjectPublicIDisposableLi1ByInByBoUnique)null);
				if (_forceSpawnActive)
				{
					_forceSpawnActive = false;
					ObjectPublicBoInBoCSItBoInSiBySiUnique client = MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.GetClient(clientId);
					MonoBehaviourPublicObInCoIE85SiAwVoFoCoUnique.PlayerSpawnRequest(clientId, streamerMode, Il2CppStructArray<byte>.op_Implicit(client.get_deobf_drip()), client.get_deobf_dripLength());
				}
				else
				{
					ObjectPublicIDisposableLi1ByInByBoUnique val = new ObjectPublicIDisposableLi1ByInByBoUnique();
					val.SetBytes(BitConverter.GetBytes(streamerMode));
					MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique.GameRequestToSpawn(clientId, val);
					val.Dispose();
				}
			}
		}
	}
	public static class GiveUtil
	{
		[CompilerGenerated]
		private sealed class <GiveItemCoroutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ulong clientId;

			public int itemId;

			public int ammo;

			private int <uniqueObjectId>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Expected O, but got Unknown
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<uniqueObjectId>5__2 = MonoBehaviourPublicDi2InObInObInUnique.Instance.GetNextId();
					MonoBehaviourPublicInInUnique.DropItem(clientId, itemId, <uniqueObjectId>5__2, ammo);
					<>2__current = (object)new WaitForSeconds(Mathf.Min((float)(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.get_clients()[MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.steamIdToUID[clientId]].get_ping() + 50) / 1000f, 1f));
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if (!MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers.ContainsKey(clientId) || MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[clientId].dead || !MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.steamIdToUID.ContainsKey(clientId) || !MonoBehaviourPublicDi2InObInObInUnique.Instance.get_sharedObjects().ContainsKey(<uniqueObjectId>5__2))
					{
						return false;
					}
					ObjectPublicIDisposableLi1ByInByBoUnique val = new ObjectPublicIDisposableLi1ByInByBoUnique();
					val.SetBytes(BitConverter.GetBytes(<uniqueObjectId>5__2));
					MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique.TryInteract(clientId, val);
					val.Dispose();
					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 GiveItem(ulong clientId, int itemId, int ammo = -1)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Invalid comparison between Unknown and I4
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Invalid comparison between Unknown and I4
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Invalid comparison between Unknown and I4
			if (MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers.ContainsKey(clientId) && !MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[clientId].dead && MonoBehaviourPublicDi2InItidGamoObInUnique.idToItem.ContainsKey(itemId))
			{
				if ((int)MonoBehaviourPublicDi2InItidGamoObInUnique.idToItem[itemId].type == 4 || (int)MonoBehaviourPublicDi2InItidGamoObInUnique.idToItem[itemId].type == 5)
				{
					MonoBehaviourPublicInInUnique.DropItem(clientId, itemId, MonoBehaviourPublicDi2InObInObInUnique.Instance.GetNextId(), (ammo < 0) ? MonoBehaviourPublicDi2InItidGamoObInUnique.idToItem[itemId].maxAmmo : ammo);
				}
				else if ((int)MonoBehaviourPublicDi2InItidGamoObInUnique.idToItem[itemId].type == 2 || (int)MonoBehaviourPublicDi2InItidGamoObInUnique.idToItem[itemId].type == 3 || ammo < 0 || ammo == MonoBehaviourPublicDi2InItidGamoObInUnique.idToItem[itemId].maxAmmo)
				{
					MonoBehaviourPublicObInCoIE85SiAwVoFoCoUnique.ForceGiveWeapon(clientId, itemId, MonoBehaviourPublicDi2InObInObInUnique.Instance.GetNextId());
				}
				else
				{
					MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)MonoBehaviourPublicObInCoIE85SiAwVoFoCoUnique.Instance, GiveItemCoroutine(clientId, itemId, (ammo < 0) ? MonoBehaviourPublicDi2InItidGamoObInUnique.idToItem[itemId].maxAmmo : ammo));
				}
			}
		}

		[IteratorStateMachine(typeof(<GiveItemCoroutine>d__1))]
		private static IEnumerator GiveItemCoroutine(ulong clientId, int itemId, int ammo)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GiveItemCoroutine>d__1(0)
			{
				clientId = clientId,
				itemId = itemId,
				ammo = ammo
			};
		}
	}
}
namespace CrabDevKit.Intermediary
{
	public static class AssignSharedObjectIDExtensions
	{
		public static List<MonoBehaviourPublicInidBoskUnique> get_sharedObjects()
		{
			return MonoBehaviourPublicLi1ObUnique.field_Private_Static_List_1_MonoBehaviourPublicInidBoskUnique_0;
		}

		public static void set_sharedObjects(List<MonoBehaviourPublicInidBoskUnique> sharedObjects)
		{
			MonoBehaviourPublicLi1ObUnique.field_Private_Static_List_1_MonoBehaviourPublicInidBoskUnique_0 = sharedObjects;
		}
	}
	public static class BlockManagerExtensions
	{
		public static Random get_random(this MonoBehaviourPublicSipiGaLipi1InGaLi10 self)
		{
			return self.field_Private_Random_0;
		}

		public static void set_random(this MonoBehaviourPublicSipiGaLipi1InGaLi10 self, Random random)
		{
			self.field_Private_Random_0 = random;
		}
	}
	public static class BoulderControllerExtensions
	{
		public static float get_spawnRate(this MonoBehaviourPublicTrspGaboSiObInUnique self)
		{
			return self.field_Private_Single_0;
		}

		public static void set_spawnRate(this MonoBehaviourPublicTrspGaboSiObInUnique self, float spawnRate)
		{
			self.field_Private_Single_0 = spawnRate;
		}

		public static void SendBoulder(this MonoBehaviourPublicTrspGaboSiObInUnique self)
		{
			self.Method_Private_Void_PDM_39();
		}
	}
	public static class BouncePlayerExtensions
	{
		public static bool get_ready(this MonoBehaviourPublicSicofoSimuupInSiboVeUnique self)
		{
			return self.field_Private_Boolean_0;
		}

		public static void set_ready(this MonoBehaviourPublicSicofoSimuupInSiboVeUnique self, bool ready)
		{
			self.field_Private_Boolean_0 = ready;
		}
	}
	public static class BulletPrefabExtensions
	{
		public static void StopBullet(this MonoBehaviourPublicInPabusmPaGahiUnique self)
		{
			self.Method_Private_Void_PDM_9();
		}
	}
	public static class BustlingButtonInteractExtensions
	{
		public static Vector3 get_activePosition(this MonoBehaviour1PublicInbuBoacAumobtAuVeSiUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.field_Private_Vector3_0;
		}

		public static void set_activePosition(this MonoBehaviour1PublicInbuBoacAumobtAuVeSiUnique self, Vector3 activePosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			self.field_Private_Vector3_0 = activePosition;
		}

		public static Vector3 get_inactivePosition(this MonoBehaviour1PublicInbuBoacAumobtAuVeSiUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.field_Private_Vector3_1;
		}

		public static void set_inactivePosition(this MonoBehaviour1PublicInbuBoacAumobtAuVeSiUnique self, Vector3 inactivePosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			self.field_Private_Vector3_1 = inactivePosition;
		}

		public static Vector3 get_desiredPosition(this MonoBehaviour1PublicInbuBoacAumobtAuVeSiUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.field_Private_Vector3_2;
		}

		public static void set_desiredPosition(this MonoBehaviour1PublicInbuBoacAumobtAuVeSiUnique self, Vector3 desiredPosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			self.field_Private_Vector3_2 = desiredPosition;
		}

		public static Vector3 get_startPosition(this MonoBehaviour1PublicInbuBoacAumobtAuVeSiUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.field_Private_Vector3_3;
		}

		public static void set_startPosition(this MonoBehaviour1PublicInbuBoacAumobtAuVeSiUnique self, Vector3 startPosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			self.field_Private_Vector3_3 = startPosition;
		}

		public static float get_moveTime(this MonoBehaviour1PublicInbuBoacAumobtAuVeSiUnique self)
		{
			return self.field_Private_Single_0;
		}

		public static void set_moveTime(this MonoBehaviour1PublicInbuBoacAumobtAuVeSiUnique self, float moveTime)
		{
			self.field_Private_Single_0 = moveTime;
		}

		public static float get_currentTime(this MonoBehaviour1PublicInbuBoacAumobtAuVeSiUnique self)
		{
			return self.field_Private_Single_1;
		}

		public static void set_currentTime(this MonoBehaviour1PublicInbuBoacAumobtAuVeSiUnique self, float currentTime)
		{
			self.field_Private_Single_1 = currentTime;
		}
	}
	public static class ButtonTimerExtensions
	{
		public static GameModePublicInSiUISiIncuneSiUIBoUnique get_gameMode(this MonoBehaviourPublicTetinoTeneRacoTeCogrUnique self)
		{
			return self.field_Private_GameModePublicInSiUISiIncuneSiUIBoUnique_0;
		}

		public static void set_gameMode(this MonoBehaviourPublicTetinoTeneRacoTeCogrUnique self, GameModePublicInSiUISiIncuneSiUIBoUnique gameMode)
		{
			self.field_Private_GameModePublicInSiUISiIncuneSiUIBoUnique_0 = gameMode;
		}
	}
	public static class CameraControllerExtensions
	{
		public static int get_currentCamera(this MonoBehaviourPublicGacaInSiAucamuclAumoUnique self)
		{
			return self.field_Private_Int32_0;
		}

		public static void set_currentCamera(this MonoBehaviourPublicGacaInSiAucamuclAumoUnique self, int currentCamera)
		{
			self.field_Private_Int32_0 = currentCamera;
		}

		public static void NextCamera(this MonoBehaviourPublicGacaInSiAucamuclAumoUnique self)
		{
			self.Method_Private_Void_PDM_37();
		}
	}
	public static class CameraRecoilExtensions
	{
		public static Vector3 get_currentRotation(this MonoBehaviourPublicVeVeUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.field_Private_Vector3_0;
		}

		public static void set_currentRotation(this MonoBehaviourPublicVeVeUnique self, Vector3 currentRotation)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			self.field_Private_Vector3_0 = currentRotation;
		}
	}
	public static class CameraShakerExtensions
	{
		public static Shaker get_shaker(this MonoBehaviourPublicShdaguShpuheObShInShUnique self)
		{
			return self.field_Private_Shaker_0;
		}

		public static void set_shaker(this MonoBehaviourPublicShdaguShpuheObShInShUnique self, Shaker shaker)
		{
			self.field_Private_Shaker_0 = shaker;
		}
	}
	public static class ChatboxExtensions
	{
		public static Color get_console(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.field_Private_Color_0;
		}

		public static void set_console(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self, Color console)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			self.field_Private_Color_0 = console;
		}

		public static int get_maxMsgLength(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			return self.field_Private_Int32_0;
		}

		public static void set_maxMsgLength(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self, int maxMsgLength)
		{
			self.field_Private_Int32_0 = maxMsgLength;
		}

		public static int get_maxChars(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			return self.field_Private_Int32_1;
		}

		public static void set_maxChars(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self, int maxChars)
		{
			self.field_Private_Int32_1 = maxChars;
		}

		public static int get_purgeAmount(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			return self.field_Private_Int32_2;
		}

		public static void set_purgeAmount(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self, int purgeAmount)
		{
			self.field_Private_Int32_2 = purgeAmount;
		}

		public static int get_deobf_maxConsecutiveChars(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			return self.field_Private_Int32_3;
		}

		public static void set_deobf_maxConsecutiveChars(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self, int deobf_maxConsecutiveChars)
		{
			self.field_Private_Int32_3 = deobf_maxConsecutiveChars;
		}

		public static List<string> get_profanity(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			return self.field_Private_List_1_String_0;
		}

		public static void set_profanity(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self, List<string> profanity)
		{
			self.field_Private_List_1_String_0 = profanity;
		}

		public static string get_deobf_messageContents(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			return self.field_Private_String_0;
		}

		public static void set_deobf_messageContents(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self, string deobf_messageContents)
		{
			self.field_Private_String_0 = deobf_messageContents;
		}

		public static string get_deobf_message(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			return self.field_Private_String_1;
		}

		public static void set_deobf_message(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self, string deobf_message)
		{
			self.field_Private_String_1 = deobf_message;
		}

		public static string get_deobf_newLine(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			return self.field_Private_String_2;
		}

		public static void set_deobf_newLine(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self, string deobf_newLine)
		{
			self.field_Private_String_2 = deobf_newLine;
		}

		public static bool get_backing_typing(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			return self.field_Private_Boolean_0;
		}

		public static void set_backing_typing(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self, bool backing_typing)
		{
			self.field_Private_Boolean_0 = backing_typing;
		}

		public static bool get_deobf_ready(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			return self.field_Private_Boolean_0;
		}

		public static void set_deobf_ready(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self, bool deobf_ready)
		{
			self.field_Private_Boolean_1 = deobf_ready;
		}

		public static Regex get_deobf_removeMultipleSpaces()
		{
			return MonoBehaviourPublicRaovTMinTemeColoonCoUnique.field_Private_Static_Regex_0;
		}

		public static void set_deobf_removeMultipleSpaces(Regex deobf_removeMultipleSpaces)
		{
			MonoBehaviourPublicRaovTMinTemeColoonCoUnique.field_Private_Static_Regex_0 = deobf_removeMultipleSpaces;
		}

		public static bool get_typing(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			return self.typing;
		}

		public static void set_typing(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self, bool typing)
		{
			self.typing = typing;
		}

		public static void UserInput(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			self.Method_Private_Void_0();
		}

		public static void ShowChat(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			self.Method_Private_Void_1();
		}

		public static void Deobf_Cooldown(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			self.Method_Private_Void_PDM_38();
		}

		public static void HideChat(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			self.Method_Private_Void_PDM_40();
		}

		public static string TrimMessage(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self, string message)
		{
			return self.Method_Private_String_String_0(message);
		}

		public static void ClearMessage(this MonoBehaviourPublicRaovTMinTemeColoonCoUnique self)
		{
			self.Method_Private_Void_2();
		}
	}
	public static class CinameticCameraExtensions
	{
		public static Vector3 get_desiredPosition(this MonoBehaviourPublicSispsiSifrVeSiUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.field_Private_Vector3_0;
		}

		public static void set_desiredPosition(this MonoBehaviourPublicSispsiSifrVeSiUnique self, Vector3 desiredPosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			self.field_Private_Vector3_0 = desiredPosition;
		}

		public static void NewShake(this MonoBehaviourPublicSispsiSifrVeSiUnique self)
		{
			self.Method_Private_Void_PDM_49();
		}
	}
	public static class CircleRatioUIExtensions
	{
		public static float get_currentValue(this MonoBehaviourPublicImciTetemaTeSiInSiBoUnique self)
		{
			return self.field_Private_Single_0;
		}

		public static void set_currentValue(this MonoBehaviourPublicImciTetemaTeSiInSiBoUnique self, float currentValue)
		{
			self.field_Private_Single_0 = currentValue;
		}

		public static float get_desiredValue(this MonoBehaviourPublicImciTetemaTeSiInSiBoUnique self)
		{
			return self.field_Private_Single_1;
		}

		public static void set_desiredValue(this MonoBehaviourPublicImciTetemaTeSiInSiBoUnique self, float desiredValue)
		{
			self.field_Private_Single_1 = desiredValue;
		}

		public static float get_currentValueMax(this MonoBehaviourPublicImciTetemaTeSiInSiBoUnique self)
		{
			return self.field_Private_Single_2;
		}

		public static void set_currentValueMax(this MonoBehaviourPublicImciTetemaTeSiInSiBoUnique self, float currentValueMax)
		{
			self.field_Private_Single_2 = currentValueMax;
		}

		public static float get_desiredValueMax(this MonoBehaviourPublicImciTetemaTeSiInSiBoUnique self)
		{
			return self.field_Private_Single_3;
		}

		public static void set_desiredValueMax(this MonoBehaviourPublicImciTetemaTeSiInSiBoUnique self, float desiredValueMax)
		{
			self.field_Private_Single_3 = desiredValueMax;
		}

		public static int get_maxValue(this MonoBehaviourPublicImciTetemaTeSiInSiBoUnique self)
		{
			return self.field_Private_Int32_0;
		}

		public static void set_maxValue(this MonoBehaviourPublicImciTetemaTeSiInSiBoUnique self, int maxValue)
		{
			self.field_Private_Int32_0 = maxValue;
		}
	}
	public static class ClientExtensions
	{
		public static bool get_activePlayer(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return self.field_Public_Boolean_0;
		}

		public static void set_activePlayer(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, bool activePlayer)
		{
			self.field_Public_Boolean_0 = activePlayer;
		}

		public static bool get_readyToLoad(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return self.field_Public_Boolean_1;
		}

		public static void set_readyToLoad(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, bool readyToLoad)
		{
			self.field_Public_Boolean_1 = readyToLoad;
		}

		public static bool get_isLoading(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return self.field_Public_Boolean_2;
		}

		public static void set_isLoading(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, bool isLoading)
		{
			self.field_Public_Boolean_2 = isLoading;
		}

		public static bool get_vcEnabled(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return self.field_Public_Boolean_3;
		}

		public static void set_vcEnabled(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, bool vcEnabled)
		{
			self.field_Public_Boolean_3 = vcEnabled;
		}

		public static bool get_kicked(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return self.field_Public_Boolean_4;
		}

		public static void set_kicked(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, bool kicked)
		{
			self.field_Public_Boolean_4 = kicked;
		}

		public static bool get_punchCooldown(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return self.field_Public_Boolean_5;
		}

		public static void set_punchCooldown(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, bool punchCooldown)
		{
			self.field_Public_Boolean_5 = punchCooldown;
		}

		public static bool get_deobf_chatCooldown(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return self.field_Public_Boolean_6;
		}

		public static void set_deobf_chatCooldown(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, bool deobf_chatCooldown)
		{
			self.field_Public_Boolean_6 = deobf_chatCooldown;
		}

		public static bool get_deobf_hasDrip(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return self.field_Public_Boolean_7;
		}

		public static void set_deobf_hasDrip(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, bool deobf_hasDrip)
		{
			self.field_Public_Boolean_7 = deobf_hasDrip;
		}

		public static int get_ping(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return self.field_Public_Int32_0;
		}

		public static void set_ping(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, int ping)
		{
			self.field_Public_Int32_0 = ping;
		}

		public static int get_colorId(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return self.field_Public_Int32_1;
		}

		public static void set_colorId(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, int colorId)
		{
			self.field_Public_Int32_1 = colorId;
		}

		public static int get_money(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return self.field_Public_Int32_2;
		}

		public static void set_money(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, int money)
		{
			self.field_Public_Int32_2 = money;
		}

		public static int get_deobf_dripLength(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return self.field_Public_Int32_3;
		}

		public static void set_deobf_dripLength(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, int deobf_dripLength)
		{
			self.field_Public_Int32_3 = deobf_dripLength;
		}

		public static CSteamID get_steamId(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.field_Public_CSteamID_0;
		}

		public static void set_steamId(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, CSteamID steamId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			self.field_Public_CSteamID_0 = steamId;
		}

		public static ItemData[] get_inventory(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return Il2CppArrayBase<ItemData>.op_Implicit((Il2CppArrayBase<ItemData>)(object)self.field_Public_ArrayOf_ItemData_0);
		}

		public static void set_inventory(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, ItemData[] inventory)
		{
			self.field_Public_ArrayOf_ItemData_0 = Il2CppReferenceArray<ItemData>.op_Implicit(inventory);
		}

		public static float get_punchCooldownTime(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return self.field_Private_Single_0;
		}

		public static void set_punchCooldownTime(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, float punchCooldownTime)
		{
			self.field_Private_Single_0 = punchCooldownTime;
		}

		public static float get_deobf_chatCooldownTime(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return self.field_Public_Single_0;
		}

		public static void set_deobf_chatCooldownTime(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, float deobf_chatCooldownTime)
		{
			self.field_Public_Single_0 = deobf_chatCooldownTime;
		}

		public static byte[] get_deobf_drip(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			return Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)self.field_Public_ArrayOf_Byte_0);
		}

		public static void set_deobf_drip(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, byte[] deobf_drip)
		{
			self.field_Public_ArrayOf_Byte_0 = Il2CppStructArray<byte>.op_Implicit(deobf_drip);
		}

		public static bool Deobf_HasItemById(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, int itemId)
		{
			return self.Method_Public_Boolean_Int32_0(itemId);
		}

		public static void HandleItem(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, MonoBehaviour1PublicAbstractItitBoGapiTrrileTrObUnique item)
		{
			self.Method_Public_Void_MonoBehaviour1PublicAbstractItitBoGapiTrrileTrObUnique_1(item);
		}

		public static void Deobf_SetDrip(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, byte[] deobf_drip, int deobf_dripLength)
		{
			self.Method_Public_Void_ArrayOf_Byte_Int32_0(Il2CppStructArray<byte>.op_Implicit(deobf_drip), deobf_dripLength);
		}

		public static void ResetClient(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			self.Method_Private_Void_PDM_0();
		}

		public static void StartPunchCooldown(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			self.Method_Public_Void_1();
		}

		public static void RemoveItem(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, int objectId)
		{
			self.Method_Public_Void_Int32_0(objectId);
		}

		public static void AddItem(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, MonoBehaviour1PublicAbstractItitBoGapiTrrileTrObUnique item)
		{
			self.Method_Public_Void_MonoBehaviour1PublicAbstractItitBoGapiTrrileTrObUnique_5(item);
		}

		public static void AddAmmo(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, MonoBehaviour1PublicAbstractItitBoGapiTrrileTrObUnique item)
		{
			self.Method_Public_Void_MonoBehaviour1PublicAbstractItitBoGapiTrrileTrObUnique_6(item);
		}

		public static bool HasItem(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, int itemId, int objectId)
		{
			return self.Method_Public_Boolean_Int32_Int32_0(itemId, objectId);
		}

		public static void DropInventory(this ObjectPublicBoInBoCSItBoInSiBySiUnique self)
		{
			self.Method_Public_Void_3();
		}

		public static void Deobf_RemoveItemById(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, int itemId)
		{
			self.Method_Public_Void_Int32_1(itemId);
		}

		public static void AddItem(this ObjectPublicBoInBoCSItBoInSiBySiUnique self, ItemData item)
		{
			self.Method_Public_Void_ItemData_2(item);
		}
	}
	public static class ClientHandleExtensions
	{
		public static ulong get_deobf_spectatorId()
		{
			return MonoBehaviourPublicUIInUIByUIUnique.field_Private_Static_UInt64_0;
		}

		public static void set_deobf_spectatorId(ulong deobf_spectatorId)
		{
			MonoBehaviourPublicUIInUIByUIUnique.field_Private_Static_UInt64_0 = deobf_spectatorId;
		}

		public static ulong get_deobf_spectatingId()
		{
			return MonoBehaviourPublicUIInUIByUIUnique.field_Private_Static_UInt64_1;
		}

		public static void set_deobf_spectatingId(ulong deobf_spectatingId)
		{
			MonoBehaviourPublicUIInUIByUIUnique.field_Private_Static_UInt64_1 = deobf_spectatingId;
		}

		public static ulong get_deobf_clientId()
		{
			return MonoBehaviourPublicUIInUIByUIUnique.field_Private_Static_UInt64_2;
		}

		public static void set_deobf_clientId(ulong deobf_clientId)
		{
			MonoBehaviourPublicUIInUIByUIUnique.field_Private_Static_UInt64_2 = deobf_clientId;
		}

		public static int get_deobf_dripLength()
		{
			return MonoBehaviourPublicUIInUIByUIUnique.field_Private_Static_Int32_0;
		}

		public static void set_deobf_dripLength(int deobf_dripLength)
		{
			MonoBehaviourPublicUIInUIByUIUnique.field_Private_Static_Int32_0 = deobf_dripLength;
		}

		public static byte[] get_deobf_drip()
		{
			return Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)MonoBehaviourPublicUIInUIByUIUnique.field_Private_Static_ArrayOf_Byte_0);
		}

		public static void set_deobf_drip(byte[] deobf_drip)
		{
			MonoBehaviourPublicUIInUIByUIUnique.field_Private_Static_ArrayOf_Byte_0 = Il2CppStructArray<byte>.op_Implicit(deobf_drip);
		}

		public static void ActuallyLoad()
		{
			MonoBehaviourPublicUIInUIByUIUnique.Method_Private_Static_Void_PDM_0();
		}

		public static void LoadWinnerScene()
		{
			MonoBehaviourPublicUIInUIByUIUnique.Method_Private_Static_Void_PDM_2();
		}
	}
	public static class ClientSendExtensions
	{
		public static int get_deobf_reliable()
		{
			return MonoBehaviourPublicInpabyInInInUnique.field_Private_Static_Int32_0;
		}

		public static void set_deobf_reliable(int deobf_reliable)
		{
			MonoBehaviourPublicInpabyInInInUnique.field_Private_Static_Int32_0 = deobf_reliable;
		}

		public static int get_deobf_unreliable()
		{
			return MonoBehaviourPublicInpabyInInInUnique.field_Private_Static_Int32_1;
		}

		public static void set_deobf_unreliable(int deobf_unreliable)
		{
			MonoBehaviourPublicInpabyInInInUnique.field_Private_Static_Int32_1 = deobf_unreliable;
		}

		public static void SendTCPData(ObjectPublicIDisposableLi1ByInByBoUnique packet)
		{
			MonoBehaviourPublicInpabyInInInUnique.Method_Private_Static_Void_ObjectPublicIDisposableLi1ByInByBoUnique_2(packet);
		}

		public static void SendTCPData(ObjectPublicIDisposableLi1ByInByBoUnique packet, ulong clientId)
		{
			MonoBehaviourPublicInpabyInInInUnique.Method_Private_Static_Void_ObjectPublicIDisposableLi1ByInByBoUnique_UInt64_0(packet, clientId);
		}

		public static void SendUDPData(ObjectPublicIDisposableLi1ByInByBoUnique packet)
		{
			MonoBehaviourPublicInpabyInInInUnique.Method_Private_Static_Void_ObjectPublicIDisposableLi1ByInByBoUnique_1(packet);
		}

		public static void SendUDPData(ObjectPublicIDisposableLi1ByInByBoUnique packet, ulong clientId)
		{
			MonoBehaviourPublicInpabyInInInUnique.Method_Private_Static_Void_ObjectPublicIDisposableLi1ByInByBoUnique_UInt64_1(packet, clientId);
		}
	}
	public static class ControlSettingExtensions
	{
		public static string get_actionName(this MonoBehaviour1PublicTekeIncuStUnique self)
		{
			return self.field_Private_String_0;
		}

		public static void set_actionName(this MonoBehaviour1PublicTekeIncuStUnique self, string actionName)
		{
			self.field_Private_String_0 = actionName;
		}

		public static void UpdateSetting(this MonoBehaviour1PublicTekeIncuStUnique self)
		{
			self.Method_Private_Void_0();
		}

		public static string intToKeyCode(this MonoBehaviour1PublicTekeIncuStUnique self, int keyCode)
		{
			return self.Method_Private_String_Int32_0(keyCode);
		}
	}
	public static class DamageNumbersExtensions
	{
		public static Vector3 get_desiredPos(this MonoBehaviourPublicTeteVeVeUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.field_Private_Vector3_0;
		}

		public static void set_desiredPos(this MonoBehaviourPublicTeteVeVeUnique self, Vector3 desiredPos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			self.field_Private_Vector3_0 = desiredPos;
		}

		public static Vector3 get_shooterPos(this MonoBehaviourPublicTeteVeVeUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.field_Private_Vector3_1;
		}

		public static void set_shooterPos(this MonoBehaviourPublicTeteVeVeUnique self, Vector3 shooterPos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			self.field_Private_Vector3_1 = shooterPos;
		}

		public static void StartFade(this MonoBehaviourPublicTeteVeVeUnique self)
		{
			self.Method_Private_Void_PDM_13();
		}
	}
	public static class DebugNetExtensions
	{
		public static bool get_fpsOn(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self)
		{
			return self.field_Private_Boolean_0;
		}

		public static void set_fpsOn(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self, bool fpsOn)
		{
			self.field_Private_Boolean_0 = fpsOn;
		}

		public static bool get_speedOn(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self)
		{
			return self.field_Private_Boolean_1;
		}

		public static void set_speedOn(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self, bool speedOn)
		{
			self.field_Private_Boolean_1 = speedOn;
		}

		public static bool get_pingOn(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self)
		{
			return self.field_Private_Boolean_2;
		}

		public static void set_pingOn(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self, bool pingOn)
		{
			self.field_Private_Boolean_2 = pingOn;
		}

		public static bool get_bandwidthOn(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self)
		{
			return self.field_Private_Boolean_3;
		}

		public static void set_bandwidthOn(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self, bool bandwidthOn)
		{
			self.field_Private_Boolean_3 = bandwidthOn;
		}

		public static float get_deltaTime(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self)
		{
			return self.field_Private_Single_0;
		}

		public static void set_deltaTime(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self, float deltaTime)
		{
			self.field_Private_Single_0 = deltaTime;
		}

		public static float get_byteUp(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self)
		{
			return self.field_Private_Single_1;
		}

		public static void set_byteUp(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self, float byteUp)
		{
			self.field_Private_Single_1 = byteUp;
		}

		public static float get_byteDown(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self)
		{
			return self.field_Private_Single_2;
		}

		public static void set_byteDown(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self, float byteDown)
		{
			self.field_Private_Single_2 = byteDown;
		}

		public static float get_pSent(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self)
		{
			return self.field_Private_Single_3;
		}

		public static void set_pSent(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self, float pSent)
		{
			self.field_Private_Single_3 = pSent;
		}

		public static float get_pReceived(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self)
		{
			return self.field_Private_Single_4;
		}

		public static void set_pReceived(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self, float pReceived)
		{
			self.field_Private_Single_4 = pReceived;
		}

		public static void Fps(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self)
		{
			self.Method_Private_Void_0();
		}

		public static void Bandwidth(this MonoBehaviourPublicTefpGacoBoSiBoLi1BoUnique self)
		{
			self.Method_Private_Void_PDM_45();
		}
	}
	public static class DecalsExtensions
	{
		public static List<MeshRenderer> get_decalPool(this MonoBehaviourPublicGadeLi1MeInObInInUnique self)
		{
			return self.field_Private_List_1_MeshRenderer_0;
		}

		public static void set_decalPool(this MonoBehaviourPublicGadeLi1MeInObInInUnique self, List<MeshRenderer> decalPool)
		{
			self.field_Private_List_1_MeshRenderer_0 = decalPool;
		}

		public static int get_index(this MonoBehaviourPublicGadeLi1MeInObInInUnique self)
		{
			return self.field_Private_Int32_0;
		}

		public static void set_index(this MonoBehaviourPublicGadeLi1MeInObInInUnique self, int index)
		{
			self.field_Private_Int32_0 = index;
		}

		public static int get_maxSize(this MonoBehaviourPublicGadeLi1MeInObInInUnique self)
		{
			return self.field_Private_Int32_1;
		}

		public static void set_maxSize(this MonoBehaviourPublicGadeLi1MeInObInInUnique self, int maxSize)
		{
			self.field_Private_Int32_1 = maxSize;
		}
	}
	public static class DestroyObjectExtensions
	{
		public static void DestroySelf(this MonoBehaviourPublicSitiUnique self)
		{
			self.Method_Private_Void_PDM_3();
		}
	}
	public static class DetectItemsExtensions
	{
		public static void RemoveHighlight(this MonoBehaviourPublicLawhTrcaGacuMaouUnique self)
		{
			self.Method_Private_Void_PDM_3();
		}

		public static void AddHighlight(this MonoBehaviourPublicLawhTrcaGacuMaouUnique self, GameObject gameObject)
		{
			self.Method_Private_Void_GameObject_PDM_11(gameObject);
		}

		public static void CheckHighlight(this MonoBehaviourPublicLawhTrcaGacuMaouUnique self, GameObject gameObject)
		{
			self.Method_Private_Void_GameObject_PDM_20(gameObject);
		}

		public static void CheckForItems(this MonoBehaviourPublicLawhTrcaGacuMaouUnique self)
		{
			self.Method_Private_Void_PDM_85();
		}
	}
	public static class DiffuseAudioExtensions
	{
		public static float get_backing_defaultVolume(this MonoBehaviourPublicSiBoSimudiSiAusofiAuUnique self)
		{
			return self.field_Private_Single_0;
		}

		public static void set_backing_defaultVolume(this MonoBehaviourPublicSiBoSimudiSiAusofiAuUnique self, float backing_defaultVolume)
		{
			self.field_Private_Single_0 = backing_defaultVolume;
		}

		public static float get_multiplier(this MonoBehaviourPublicSiBoSimudiSiAusofiAuUnique self)
		{
			return self.field_Private_Single_1;
		}

		public static void set_multiplier(this MonoBehaviourPublicSiBoSimudiSiAusofiAuUnique self, float multiplier)
		{
			self.field_Private_Single_1 = multiplier;
		}

		public static float get_defaultHz(this MonoBehaviourPublicSiBoSimudiSiAusofiAuUnique self)
		{
			return self.field_Private_Single_2;
		}

		public static void set_defaultHz(this MonoBehaviourPublicSiBoSimudiSiAusofiAuUnique self, float defaultHz)
		{
			self.field_Private_Single_2 = defaultHz;
		}

		public static float get_volumeMultiplier(this MonoBehaviourPublicSiBoSimudiSiAusofiAuUnique self)
		{
			return self.field_Private_Single_3;
		}

		public static void set_volumeMultiplier(this MonoBehaviourPublicSiBoSimudiSiAusofiAuUnique self, float volumeMultiplier)
		{
			self.field_Private_Single_3 = volumeMultiplier;
		}

		public static float get_filterMultiplier(this MonoBehaviourPublicSiBoSimudiSiAusofiAuUnique self)
		{
			return self.field_Private_Single_4;
		}

		public static void set_filterMultiplier(this MonoBehaviourPublicSiBoSimudiSiAusofiAuUnique self, float filterMultiplier)
		{
			self.field_Private_Single_4 = filterMultiplier;
		}

		public static float get_defaultVolume(this MonoBehaviourPublicSiBoSimudiSiAusofiAuUnique self)
		{
			return self.defaultVolume;
		}

		public static void set_defaultVolume(this MonoBehaviourPublicSiBoSimudiSiAusofiAuUnique self, float defaultVolume)
		{
			self.defaultVolume = defaultVolume;
		}
	}
	public static class DisplayNameUIExtensions
	{
		public static bool get_hidden(this MonoBehaviourPublicTenaBoUnique self)
		{
			return self.field_Private_Boolean_0;
		}

		public static void set_hidden(this MonoBehaviourPublicTenaBoUnique self, bool hidden)
		{
			self.field_Private_Boolean_0 = hidden;
		}
	}
	public static class DissonanceManagerExtensions
	{
		public static void OnPlayerJoined(this MonoBehaviourPublicObdicoObInGaObdiUnique self, ObjectPublicAbstractObStAc12ObAc1BoStUnique player)
		{
			self.Method_Private_Void_ObjectPublicAbstractObStAc12ObAc1BoStUnique_4(player);
		}
	}
	public static class DissonancePlayerExtensions
	{
		public static bool get_isTracking(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			return self.field_Private_Boolean_0;
		}

		public static void set_isTracking(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self, bool isTracking)
		{
			self.field_Private_Boolean_0 = isTracking;
		}

		public static bool get_isLocal(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			return self.field_Private_Boolean_1;
		}

		public static void set_isLocal(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self, bool isLocal)
		{
			self.field_Private_Boolean_1 = isLocal;
		}

		public static string get_playerId(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			return self.field_Private_String_0;
		}

		public static void set_playerId(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self, string playerId)
		{
			self.field_Private_String_0 = playerId;
		}

		public static MonoBehaviourPublicSealedObSt_lBo_iObStBoSi_iUnique get_comms(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			return self.field_Private_MonoBehaviourPublicSealedObSt_lBo_iObStBoSi_iUnique_0;
		}

		public static void set_comms(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self, MonoBehaviourPublicSealedObSt_lBo_iObStBoSi_iUnique comms)
		{
			self.field_Private_MonoBehaviourPublicSealedObSt_lBo_iObStBoSi_iUnique_0 = comms;
		}

		public static float get_maxRadius(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			return self.field_Private_Single_0;
		}

		public static void set_maxRadius(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self, float maxRadius)
		{
			self.field_Private_Single_0 = maxRadius;
		}

		public static float get_minRadius(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			return self.field_Private_Single_1;
		}

		public static void set_minRadius(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self, float minRadius)
		{
			self.field_Private_Single_1 = minRadius;
		}

		public static int get_maxPlayers(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			return self.field_Private_Int32_0;
		}

		public static void set_maxPlayers(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self, int maxPlayers)
		{
			self.field_Private_Int32_0 = maxPlayers;
		}

		public static int get_minPlayers(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			return self.field_Private_Int32_1;
		}

		public static void set_minPlayers(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self, int minPlayers)
		{
			self.field_Private_Int32_1 = minPlayers;
		}

		public static int get_currentPlayers(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			return self.field_Private_Int32_2;
		}

		public static void set_currentPlayers(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self, int currentPlayers)
		{
			self.field_Private_Int32_2 = currentPlayers;
		}

		public static bool get_IsTracking(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			return self.IsTracking;
		}

		public static string get_PlayerId(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			return self.PlayerId;
		}

		public static Vector3 get_Position(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.Position;
		}

		public static Quaternion get_Rotation(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.Rotation;
		}

		public static EnumPublicSealedvaUnLoRe4vUnique get_Type(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.Type;
		}

		public static void SetSphereRadius(this MonoBehaviourPublicBoloStBoTrorBoObpmSpUnique self)
		{
			self.Method_Private_Void_PDM_9();
		}
	}
	public static class DropdownSettingExtensions
	{
		public static Resolution[] get_resolutions(this MonoBehaviour1PublicTMdrTeseReUnique self)
		{
			return Il2CppArrayBase<Resolution>.op_Implicit((Il2CppArrayBase<Resolution>)(object)self.field_Private_ArrayOf_Resolution_0);
		}

		public static void set_resolutions(this MonoBehaviour1PublicTMdrTeseReUnique self, Resolution[] resolutions)
		{
			self.field_Private_ArrayOf_Resolution_0 = Il2CppStructArray<Resolution>.op_Implicit(resolutions);
		}

		public static void UpdateSetting(this MonoBehaviour1PublicTMdrTeseReUnique self)
		{
			self.Method_Private_Void_6();
		}
	}
	public static class EffectManagerExtensions
	{
		public static void Deobf_DetectModding(this MonoBehaviourPublicGataInefObInUnique self, GameObject gameObject, bool unusedBool, Vector3 unusedVector3, Quaternion unusedQuaternion)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			self.Method_Private_Void_GameObject_Boolean_Vector3_Quaternion_0(gameObject, unusedBool, unusedVector3, unusedQuaternion);
		}
	}
	public static class EnableAudioExtensions
	{
		public static void Activate(this MonoBehaviourPublicGaauSitiUnique self)
		{
			self.Method_Private_Void_PDM_38();
		}
	}
	public static class EnableDepthBufferExtensions
	{
		public static Camera get_m_camera(this MonoBehaviourPublicCaUnique self)
		{
			return self.field_Private_Camera_0;
		}

		public static void set_m_camera(this MonoBehaviourPublicCaUnique self, Camera m_camera)
		{
			self.field_Private_Camera_0 = m_camera;
		}
	}
	public static class ExplodePlayerExtensions
	{
		public static float get_force(this MonoBehaviourPublicRiboSiUnique self)
		{
			return self.field_Private_Single_0;
		}

		public static void set_force(this MonoBehaviourPublicRiboSiUnique self, float force)
		{
			self.field_Private_Single_0 = force;
		}
	}
	public static class FollowTargetExtensions
	{
		public static Vector3 get_offset(this MonoBehaviourPublicTrtaBokeVeUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.field_Private_Vector3_0;
		}

		public static void set_offset(this MonoBehaviourPublicTrtaBokeVeUnique self, Vector3 offset)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			self.field_Private_Vector3_0 = offset;
		}
	}
	public static class FootStepExtensions
	{
		public static void FindGroundType(this MonoBehaviourPublicLawhObraAugegrAuUnique self)
		{
			self.Method_Private_Void_0();
		}
	}
	public static class FootstepOnTouchExtensions
	{
		public static bool get_ready(this MonoBehaviourPublicGafoBoSiUnique self)
		{
			return self.field_Private_Boolean_0;
		}

		public static void set_ready(this MonoBehaviourPublicGafoBoSiUnique self, bool ready)
		{
			self.field_Private_Boolean_0 = ready;
		}

		public static float get_cooldown(this MonoBehaviourPublicGafoBoSiUnique self)
		{
			return self.field_Private_Single_0;
		}

		public static void set_cooldown(this MonoBehaviourPublicGafoBoSiUnique self, float cooldown)
		{
			self.field_Private_Single_0 = cooldown;
		}
	}
	public static class GameAudioExtensions
	{
		public static bool get_firstTick(this MonoBehaviourPublicAuroObAuroclriAuroObUnique self)
		{
			return self.field_Private_Boolean_0;
		}

		public static void set_firstTick(this MonoBehaviourPublicAuroObAuroclriAuroObUnique self, bool firstTick)
		{
			self.field_Private_Boolean_0 = firstTick;
		}
	}
	public static class GameLoopExtensions
	{
		public static Random get_random(this MonoBehaviourPublicObInLi1GagasmLi1GaUnique self)
		{
			return self.field_Private_Random_0;
		}

		public static void set_random(this MonoBehaviourPublicObInLi1GagasmLi1GaUnique self, Random random)
		{
			self.field_Private_Random_0 = random;
		}

		public static int get_backing_currentMapIndex(this MonoBehaviourPublicObInLi1GagasmLi1GaUnique self)
		{
			return self.field_Private_Int32_0;
		}

		public static void set_backing_currentMapIndex(this MonoBehaviourPublicObInLi1GagasmLi1GaUnique self, int backing_currentMapIndex)
		{
			self.field_Private_Int32_0 = backing_currentMapIndex;
		}

		public static int get_backing_currentModeIndex(this MonoBehaviourPublicObInLi1GagasmLi1GaUnique self)
		{
			return self.field_Private_Int32_1;
		}

		public static void set_backing_currentModeIndex(this MonoBehaviourPublicObInLi1GagasmLi1GaUnique self, int backing_currentModeIndex)
		{
			self.field_Private_Int32_1 = backing_currentModeIndex;
		}

		public static int get_currentMapIndex(this MonoBehaviourPublicObInLi1GagasmLi1GaUnique self)
		{
			return self.currentMapIndex;
		}

		public static void set_currentMapIndex(this MonoBehaviourPublicObInLi1GagasmLi1GaUnique self, int currentMapIndex)
		{
			self.currentMapIndex = currentMapIndex;
		}

		public static int get_currentModeIndex(this MonoBehaviourPublicObInLi1GagasmLi1GaUnique self)
		{
			return self.currentModeIndex;
		}

		public static void set_currentModeIndex(this MonoBehaviourPublicObInLi1GagasmLi1GaUnique self, int currentModeIndex)
		{
			self.currentModeIndex = currentModeIndex;
		}

		public static void CheckDeadPlayers(this MonoBehaviourPublicObInLi1GagasmLi1GaUnique self)
		{
			self.Method_Private_Void_0();
		}

		public static void ResetGameModesList(this MonoBehaviourPublicObInLi1GagasmLi1GaUnique self)
		{
			self.Method_Private_Void_1();
		}

		public static void ResetReadyToJoin(this MonoBehaviourPublicObInLi1GagasmLi1GaUnique self)
		{
			self.Method_Private_Void_2();
		}

		public static ulong FindWinnerId(this MonoBehaviourPublicObInLi1GagasmLi1GaUnique self)
		{
			return self.Method_Private_UInt64_0();
		}
	}
	public static class GameManagerExtensions
	{
		public static GameObject get_spectatorObject(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self)
		{
			return self.field_Private_GameObject_0;
		}

		public static void set_spectatorObject(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self, GameObject spectatorObject)
		{
			self.field_Private_GameObject_0 = spectatorObject;
		}

		public static ulong get_deobf_clientId(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self)
		{
			return self.field_Private_UInt64_0;
		}

		public static void set_deobf_clientId(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self, ulong deobf_clientId)
		{
			self.field_Private_UInt64_0 = deobf_clientId;
		}

		public static Vector3 get_deobf_position(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.field_Private_Vector3_0;
		}

		public static void set_deobf_position(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self, Vector3 deobf_position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			self.field_Private_Vector3_0 = deobf_position;
		}

		public static float get_deobf_rotationX(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self)
		{
			return self.field_Private_Single_0;
		}

		public static void set_deobf_rotationX(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self, float deobf_rotationX)
		{
			self.field_Private_Single_0 = deobf_rotationX;
		}

		public static float get_deobf_rotationY(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self)
		{
			return self.field_Private_Single_1;
		}

		public static void set_deobf_rotationY(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self, float deobf_rotationY)
		{
			self.field_Private_Single_1 = deobf_rotationY;
		}

		public static EnumNPublicSealedvaCrMe3vUnique get_deobf_playerAnimation(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return self.field_Private_EnumNPublicSealedvaCrMe3vUnique_0;
		}

		public static void set_deobf_playerAnimation(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self, EnumNPublicSealedvaCrMe3vUnique deobf_playerAnimation)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			self.field_Private_EnumNPublicSealedvaCrMe3vUnique_0 = deobf_playerAnimation;
		}

		public static bool get_deobf_crouchState(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self)
		{
			return self.field_Private_Boolean_0;
		}

		public static void set_deobf_crouchState(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self, bool deobf_crouchState)
		{
			self.field_Private_Boolean_0 = deobf_crouchState;
		}

		public static int get_deobf_playersAlive(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self)
		{
			return self.field_Private_Int32_0;
		}

		public static void set_deobf_playersAlive(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self, int deobf_playersAlive)
		{
			self.field_Private_Int32_0 = deobf_playersAlive;
		}

		public static void RequestSpawn(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self)
		{
			self.Method_Private_Void_0();
		}

		public static void OnPlayerSpawnOrDespawn(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self, ulong clientId)
		{
			self.Method_Private_Void_UInt64_PDM_1(clientId);
		}

		public static IEnumerator StopPlayerVoip(this MonoBehaviourPublicDi2UIObacspDi2UIObUnique self, MonoBehaviourPublicCSstReshTrheObplBojuUnique playerManager, float speakAfterDeathTime)
		{
			return self.Method_Private_IEnumerator_MonoBehaviourPublicCSstReshTrheObplBojuUnique_Single_0(playerManager, speakAfterDeathTime);
		}
	}
	public static class GameModeExtensions
	{
		public static void UpdateTimer(this GameMode self)
		{
			self.Method_Private_Void_PDM_0();
		}

		public static void StartRound(this GameMode self)
		{
			self.Method_Private_Void_0();
		}

		public static void StartMusic(this GameMode self)
		{
			self.Method_Private_Void_PDM_1();
		}

		public static void UpdateMusic(this GameMode self)
		{
			self.Method_Private_Void_PDM_2();
		}

		public static void EndMusic(this GameMode self)
		{
			self.Method_Protected_Void_0();
		}
	}
	public static class GameModeBombTagExtensions
	{
		public static int get_bombsLeft(this GameModePublicInSiLiSiIn1UIObBoUnique self)
		{
			return self.field_Private_Int32_0;
		}

		public static void set_bombsLeft(this GameModePublicInSiLiSiIn1UIObBoUnique self, int bombsLeft)
		{
			self.field_Private_Int32_0 = bombsLeft;
		}

		public static float get_intervalTime(this GameModePublicInSiLiSiIn1UIObBoUnique self)
		{
			return self.field_Private_Single_0;
		}

		public static void set_intervalTime(this GameModePublicInSiLiSiIn1UIObBoUnique self, float intervalTime)
		{
			self.field_Private_Single_0 = intervalTime;
		}

		public static float get_fuseTime(this GameModePublicInSiLiSiIn1UIObBoUnique self)
		{
			return self.field_Private_Single_1;
		}

		public static void set_fuseTime(this GameModePublicInSiLiSiIn1UIObBoUnique self, float fuseTime)
		{
			self.field_Private_Single_1 = fuseTime;
		}

		public static int get_maxBombs(this GameModePublicInSiLiSiIn1UIObBoUnique self)
		{
			return self.field_Private_Int32_1;
		}

		public static void set_maxBombs(this GameModePublicInSiLiSiIn1UIObBoUnique self, int maxBombs)
		{
			self.field_Private_Int32_1 = maxBombs;
		}

		public static List<ulong> get_taggedPlayers(this GameModePublicInSiLiSiIn1UIObBoUnique self)
		{
			return self.field_Private_List_1_UInt64_0;
		}

		public static void set_taggedPlayers(this GameModePublicInSiLiSiIn1UIObBoUnique self, List<ulong> taggedPlayers)
		{
			self.field_Private_List_1_UInt64_0 = taggedPlayers;
		}

		public static ObjectPublicSiBoSiSiSiUnique get_bombTimer(this GameModePublicInSiLiSiIn1UIObBoUnique self)
		{
			return self.field_Private_ObjectPublicSiBoSiSiSiUnique_0;
		}

		public static void set_bombTimer(this GameModePublicInSiLiSiIn1UIObBoUnique self, ObjectPublicSiBoSiSiSiUnique bombTimer)
		{
			self.field_Private_ObjectPublicSiBoSiSiSiUnique_0 = bombTimer;
		}

		public static bool get_showedAlert(this GameModePublicInSiLiSiIn1UIObBoUnique self)
		{
			return self.field_Private_Boolean_0;
		}

		public static void set_showedAlert(this GameModePublicInSiLiSiIn1UIObBoUnique self, bool showedAlert)
		{
			self.field_Private_Boolean_0 = showedAlert;
		}

		public static List<ulong> GetAllAlivePlayers(this GameModePublicInSiLiSiIn1UIObBoUnique self)
		{
			return self.Method_Private_List_1_UInt64_2();
		}

		public static void ExplodeBomb(this GameModePublicInSiLiSiIn1UIObBoUnique self)
		{
			self.Method_Private_Void_4();
		}

		public static void SendTagPlayer(this GameModePublicInSiLiSiIn1UIObBoUnique self, ulong bomberClientId, ulong taggedClientId)
		{
			self.Method_Private_Void_UInt64_UInt64_4(bomberClientId, taggedClientId);
		}

		public static void SelectBomber(this GameModePublicInSiLiSiIn1UIObBoUnique self)
		{
			self.Method_Private_Void_5();
		}
	}
	public static class GameModeButtonsExtensions
	{
		public static int get_dangerousButton(this GameModePublicInSiUISiIncuneSiUIBoUnique self)
		{
			return self.field_Private_Int32_0;
		}

		public static void set_dangerousButton(this GameModePublicInSiUISiIncuneSiUIBoUnique self, int dangerousButton)
		{
			self.field_Private_Int32_0 = dangerousButton;
		}

		public static float get_maxModeTime(this GameModePublicInSiUISiIncuneSiUIBoUnique self)
		{
			return self.field_Private_Single_0;
		}

		public static void set_maxModeTime(this GameModePublicInSiUISiIncuneSiUIBoUnique self, float maxModeTime)
		{
			self.field_Private_Single_0 = maxModeTime;
		}

		public static float get_timeToPressButton(this GameModePublicInSiUISiIncuneSiUIBoUnique self)
		{
			return self.field_Private_Single_1;
		}

		public static void set_timeToPressButton(this GameModePublicInSiUISiIncuneSiUIBoUnique self, float timeToPressButton)
		{
			self.field_Private_Single_1 = timeToPressButton;
		}

		public static float get_timeToGetOffStage(this GameModePublicInSiUISiIncuneSiUIBoUnique self)
		{
			return self.field_Private_Single_2;
		}

		public static void set_timeToGetOffStage(this GameModePublicInSiUISiIncuneSiUIBoUnique self, float timeToGetOffStage)
		{
			self.field_Private_Single_2 = timeToGetOffStage;
		}

		public static float get_timeToRevealExplosion(this GameModePublicInSiUISiIncuneSiUIBoUnique self)
		{
			return self.field_Private_Single_3;
		}

		public static void set_timeToRevealExplosion(this GameModePublicInSiUISiIncuneSiUIBoUnique self, float timeToRevealExplosion)
		{
			self.field_Private_Single_3 = timeToRevealExplosion;
		}

		public static int get_desiredPlayersLeft(this GameModePublicInSiUISiIncuneSiUIBoUnique self)
		{
			return self.field_Private_Int32_1;
		}

		public static void set_desiredPlayersLeft(this GameModePublicInSiUISiIncuneSiUIBoUnique self, int desiredPlayersLeft)
		{
			self.field_Private_Int32_1 = desiredPlayersLeft;
		}

		public static bool get_canPressButton(this GameModePublicInSiUISiIncuneSiUIBoUnique self)
		{
			return self.field_Private_Boolean_0;
		}

		public static void set_currentButtonPresser(this GameModePublicInSiUISiIncuneSiUIBoUnique self, bool canPressButton)
		{
			self.field_Private_Boolean_0 = canPressButton;
		}

		public static int get_lastTick(this GameModePublicInSiUISiIncuneSiUIBoUnique self)
		{
			return self.field_Private_Int32_2;
		}

		public static void set_lastTick(this GameModePublicInSiUISiIncuneSiUIBoUnique self, int lastTick)
		{
			self.field_Private_Int32_2 = lastTick;
		}

		public static Random get_random(this GameModePublicInSiUISiIncuneSiUIBoUnique self)
		{
			return self.field_Private_Random_0;
		}

		public static void set_random(this GameModePublicInSiUISiIncuneSiUIBoUnique self, Random random)
		{
			self.field_Private_Random_0 = random;
		}

		public static float get_killRatio(this GameModePublicInSiUISiIncuneSiUIBoUnique self)
		{
			return self.field_Private_Single_4;
		}

		public static void set_killRatio(this GameModePublicInSiUISiIncuneSiUIBoUnique self, float killRatio)
		{
			self.field_Private_Single_4 = killRatio;
		}

		public static void IncrementPlayerIndex(this GameModePublicInSiUISiIncuneSiUIBoUnique self)
		{